# Activity Feed
Source: https://v0.x-docs.novu.co/activity-feed/introduction

Monitor all your activity from one place

## Introduction

Novu provides a notification activity feed that monitors every outgoing message associated with its relevant metadata. This can be used to monitor activity and discover potential issues with a specific provider or channel type.

<Frame>
  <img />
</Frame>

## Viewing a specific subscriber's activity

To use a subscriber's activity feed you can filter the feed by using the subscriberId or email. This will show only the relevant data for this particular subscriber.

To do this, just enter the `subscriberId` or the 'email' of the subscriber you want to get info of and then click the 'search' button on the right-hand side as shown in the image below:

<Frame>
  <img />
</Frame>

## Filter by workflow or channel

The activity feed allows you to filter messages based on the associated workflow or channel. This is helpful when you want to assess or debug a particular workflow and its behaviour.

Filtering by workflow or channel is quite simple. Just go to the Workflow dropdown (if you want to filter by workflow) or the channel tab (if you want to filter by channel) and select the corresponding workflow or channel and click the 'search' button on the right-hand side as shown in the image below:

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Troubleshooting with the activity feed

The activity feed also shows if a transaction is failing. You can see why a transaction is failing and rectify it. For example, take a look at the following image:

<Frame>
  <img />
</Frame>

You can see that an SMS notification has failed to get delivered. Clicking on it opens the execution details and the reason why that transaction failed

<Frame>
  <img />
</Frame>

This can help troubleshoot the problem and comes in handy at the time of distress.

## Digest info in the activity feed

If you’re using our digest notifications functionality, you’ll be able to see all the digest-related information in the activity feed.

<Frame>
  <img />
</Frame>

Some of the information related to digest present in the activity feed is:

* Digest step delay
* Digesting start time
* Digest triggered events details
* More digest execution details

<Frame>
  <img />
</Frame>

From here, you can see the details of ‘digest triggered events’ to see exactly which events were digested and the content of the notification you sent, as shown below:

<Frame>
  <img />
</Frame>

## Trigger Event Lifecycle

### **Trigger request**

The request contains details such as the identifier for the template, the list of subscribers who will receive the notification, the payload of the notification, and any overrides that need to be applied.

### Trigger endpoint

After the request is sent to the `/event/trigger` endpoint, the initial step involves mapping and validating the subscribers for that event. Following that, we validate the template and steps based on the active status or draft template flag.

Once the validation process is complete, the attachments are uploaded to the storage service.

Next, the trigger event with mapped subscribers and attachment links is appended to the **trigger event queue**. By queuing the events, we can achieve faster response times.

### **Trigger event processing**

When the event is picked up by the **trigger queue worker** we process it. For every subscriber listed in the trigger event, we create a notification entity and the corresponding jobs based on the notification template steps. The notification contains data related to the organization, template, subscriber, and event payload. It is updated with a channels field that is generated from the steps.

### **Jobs**

Every job is created according to the steps outlined in the template. If the template contains a digest step, the **filtering logic** is applied to produce the appropriate jobs array depending on the type of digesting: **regular** or **backoff**.


# Trigger Event Lifecycle
Source: https://v0.x-docs.novu.co/activity-feed/trigger-event-lifecycle

Managing Trigger Events from Request to Processing

## Trigger Request

A trigger request is the initial step in handling a trigger event. It contains crucial details such as the template identifier, a list of subscribers who will receive the notification, the payload of the notification, and any overrides that need to be applied.

## Trigger Endpoint

Upon sending the request to the `/event/trigger` endpoint, a series of essential steps are initiated:

1. **Subscriber Mapping and Validation:** The first step involves mapping and validating the subscribers for the specified event. This ensures that notifications are sent to the correct recipients.

2. **Template Validation:** Following subscriber validation, the template associated with the event is validated. This validation process considers factors such as the active status or draft template flag to determine if it meets the necessary criteria for processing.

3. **Attachment Upload:** Once the validation process is successfully completed, any attachments associated with the event are uploaded to the designated storage service.

4. **Event Queuing:** The trigger event, now enriched with mapped subscribers and attachment links, is appended to the **trigger event queue**. This queuing mechanism optimizes response times, ensuring efficient event processing.

## Trigger Event Processing

When an event is picked up by the **trigger queue worker**, the processing phase begins. Here's what happens:

* **Notification Entity Creation:** For each subscriber listed in the trigger event, a corresponding notification entity is created. This entity contains essential data related to the organization, template, subscriber, and event payload.

* **Job Creation:** Based on the notification template's defined steps, jobs are generated. These jobs are responsible for carrying out specific tasks related to the event notification. Additionally, the notification entity is updated with a "channels" field generated from these steps, indicating the communication channels through which notifications will be sent.

## Jobs

Jobs play a pivotal role in the trigger event lifecycle. They are created based on the steps outlined in the notification template. Depending on the presence of a digest step, the following logic is applied:

* **Digest Step:** If the template includes a digest step, filtering logic is applied to produce an appropriate array of jobs. This logic differentiates between two types of digesting: **regular** and **backoff**, each serving distinct purposes in event processing.

## Job Statuses

| Status        | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **PENDING**   | This status is assigned to a job before it is added to the worker queue. It indicates that the job is waiting to be processed.                                                                                                                                                                                                                                                                                                                                                                                                                       |
| **QUEUED**    | After the initial validation and just before adding a job to the worker queue, it is set to `QUEUED`. This status signifies that the job is ready for processing but is awaiting its turn in the queue.                                                                                                                                                                                                                                                                                                                                              |
| **RUNNING**   | When a job is picked up by a worker from the queue, its status is changed to `RUNNING`. This indicates that the job is currently being processed by a worker.                                                                                                                                                                                                                                                                                                                                                                                        |
| **COMPLETED** | Once a job has been successfully executed and processed, its status is changed to `COMPLETED`. This signifies that the job has been successfully completed.                                                                                                                                                                                                                                                                                                                                                                                          |
| **FAILED**    | If a job encounters an issue during processing or execution, its status is changed to `FAILED`. This indicates that the job has not been successfully completed, and there may have been errors or problems during processing.                                                                                                                                                                                                                                                                                                                       |
| **DELAYED**   | The `DELAYED` status is applied to specific types of jobs, such as `digest` or `delay` jobs, to indicate that they are delayed and not immediately processed. For `digest` jobs, it means that the digesting process is running or scheduled for a later time. For `delay` jobs, it signifies that the job is set to be executed at a specified delay time.                                                                                                                                                                                          |
| **CANCELED**  | When a job is canceled for any reason, its status is set to `CANCELED`. This indicates that the job will not be processed further and is effectively removed from the processing queue.                                                                                                                                                                                                                                                                                                                                                              |
| **MERGED**    | The `MERGED` status is assigned to events that are part of a `digest`. It indicates that an event will be merged into the digesting event. In a digesting process, there is typically a primary or initial event that serves as the digesting event, and subsequent events are merged into it. Instead of having a separate `COMPLETED` status for these merged events, they are marked as `MERGED` to indicate their specific role in the digesting process.                                                                                        |
| **SKIPPED**   | The `SKIPPED` status is used in the context of backoff versions of digesting. In this scenario, the first event's digesting is skipped, and the second event takes on the digesting role. The `SKIPPED` status is applied to the first event's digesting, indicating that it was intentionally skipped in the digesting process. Subsequent events may be merged into the second event's digesting process, as explained with the `MERGED` status. The `SKIPPED` status helps differentiate the skipped event from others in the digesting sequence. |

**Example:**

<Frame>
  <img />
</Frame>

<Steps>
  <Step title="Step created">
    `PENDING`
  </Step>

  <Step title="Step queued">
    `QUEUED`
  </Step>

  <Step title="Start sending message">
    `RUNNING`
  </Step>

  <Step title="Message created">
    `RUNNING`
  </Step>

  <Step title="Message sent">
    `COMPLETED`
  </Step>
</Steps>


# Novu Architecture Diagram
Source: https://v0.x-docs.novu.co/architecture/diagrams



# Novu Architecture Diagram powered by [terrastruct](https://terrastruct.com) and D2

If the diagram below is not rendering, please [click here](https://app.terrastruct.com/diagrams/1895866270) to view it on terrastruct.com.

<iframe title="Novu" />


# Introduction to Novu
Source: https://v0.x-docs.novu.co/architecture/introduction

Overview of Novu's Architecture

Novu is an open-source notification infrastructure designed to provide a robust, efficient, and flexible solution for managing notifications across various platforms.
The architecture of Novu is meticulously crafted to ensure accurate delivery of notifications while maintaining high performance and scalability.

Our systems are hosted on Amazon Web Services (AWS), ensuring a reliable and secure environment for our infrastructure.
We adhere to several industry-standard compliance certifications including SOC II, PCI, and GDPR which underline our commitment to security and data privacy.

## Framework Leveraged

* **Nestjs**: A progressive Node.js framework that is used for building efficient, reliable, and scalable server-side applications. Nestjs provides a high-level abstraction with a lot of out-of-the-box features, making it a perfect choice for building modular and maintainable applications.
* **Mongoose**: An elegant Object Document Mapper (ODM) for MongoDB, which simplifies the interaction with the database by providing a straightforward modeling of the application data. Mongoose’s features like schema validation, query building, and middleware support immensely help in building robust applications.
* **BullMQ**: A robust, fast, and reliable queue library for handling distributed jobs and messages in Node.js. It is instrumental in managing the processing of notification jobs ensuring they are handled in an efficient and reliable manner.

## Databases

* **MongoDB**: A NoSQL database that provides high performance, high availability, and easy scalability. It works on a document-oriented data model, which is extremely flexible and allows for varied, complex data structures to be stored and manipulated with ease.
* **Redis**: An in-memory data structure store, used as a database, cache, and message broker. It's exceptionally fast and provides support for various data structures like strings, hashes, lists, sets, etc. It's utilized in Novu for caching and as a reliable message broker for managing queues and real-time data processing.

## Scalability & Performance

The architecture of Novu is designed to scale horizontally to handle a growing number of notification requests. The use of microservices, container orchestration with Kubernetes, and leveraging AWS’s auto-scaling capabilities, ensure that the system can handle high loads while maintaining low latency and high throughput.

## Monitoring & Observability

Monitoring and observability are crucial for ensuring the reliable operation of Novu. Utilizing tools like Prometheus and Grafana, we've built a comprehensive monitoring and alerting system that provides real-time insights into the system’s performance and health.

## Security

Security is a paramount concern in Novu’s architecture. By adhering to industry-standard security practices and compliance certifications, we ensure that the data flowing through Novu is handled securely and in compliance with regulatory requirements.


# Novu Providers
Source: https://v0.x-docs.novu.co/channels-and-providers/default-providers

Learn about the default Novu email and sms providers

## Novu Providers

To help you evaluate our services better, Novu provides an email and sms provider by default for every account. After signing up, you can go to the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-default-providers) on the Novu web dashboard to see this.

<Note>
  This feature is available only in Novu cloud. This feature will not work in community self
  hosted version and local environment.
</Note>

## Novu Email Provider

If you've a newly signed-up account on Novu, it will look like this:

<Frame>
  <img />
</Frame>

## Novu SMS Provider

And this is what the default Novu SMS provider looks like:

<Frame>
  <img />
</Frame>

<Info>
  The default email and sms providers are for evaluation purposes only and their use in production-grade apps is not recommended. You should switch to any of our [numerous other providers](/additional-resources/glossary#3-providers) for production apps. Also, there are two modes for default Novu providers - Development and Production.
</Info>

## Novu In-app Provider

In addition to email and sms, we also have in-app provider:

<Frame>
  <img />
</Frame>

It is the only provider for the in-app channel and it *can be used in production apps*. Unlike sms and email, it is not active by default and needs to be turned on separately. It can be scaled as per your need and it is a 'pay as you go' offering. You can check [this](https://novu.co/pricing/?utm_campaign=docs-default-providers) for more details.

## Limits of the Novu Providers

Following are the limits for our email and sms providers:

1. Email: 300 emails per organization per month
2. SMS: 20 messages per organization per month

To send more than these limits, you can configure a different provider for a specific channel. Read more about them [here](/channels-and-providers/integration-store).


# Amazon SES
Source: https://v0.x-docs.novu.co/channels-and-providers/email/amazon-ses

Learn how to use the Amazon SES provider to send email notifications using Novu

You can use the [Amazon SES](https://aws.amazon.com/ses/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Amazon SES provider in the email channel, you will need to create an SES account and add your credentials to the Amazon SES integration on the Novu platform.

## Setting up SES in AWS?

* Either use a root AWS account or create a new IAM account with appropriate permission policies.
  <Tip>Example policy rule `arn:aws:ses:<REGION>:<ACCOUNT>:identity/*`</Tip>
* Create a new access key and save generated `ACCESS_KEY_ID` and `ACCESS_SECRET_KEY` carefully
* Choose Amazon Simple Email Service.
* Create a new identity.
* Either choose domain or email.
* Verify your domain (by adding a few DNS records as mentioned in SES instructions) or email (AWS sends a verification email to your email).
* Verify the recipient email also by creating a new email identity type \[only in sandbox mode].
* Test if your SES is set up correctly using the test email feature.

## Creating an SES integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-integrations-ses) page on Novu.
* Click on Add a Provider.
* Select Amazon SES service.
* Enter previously saved `ACCESS_KEY_ID` and `ACCESS_SECRET_KEY`.
* Fill in the `From email address` field using the authenticated sender email id in the previous step.
* Enter `region` and `Sender name` also.

<Tip>Example region format:- `us-east-1`. By default Novu uses `us-east-1` region.</Tip>

* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Amazon SES in Novu.

## FAQs

<AccordionGroup>
  <Accordion title="Trigger from novu is successful but the subscriber is not receiving email.">
    Possible reasons:

    1. You have not verified the subscriber's email address in SES (if you are in a sandbox environment).
    2. Your daily sending limit has been reached (if you are in a sandbox environment).
    3. You have entered the wrong aws region in the integration form.
  </Accordion>
</AccordionGroup>


# Braze
Source: https://v0.x-docs.novu.co/channels-and-providers/email/braze

Learn how to use the Braze provider to send email notifications using Novu

You can use the [Braze](https://braze.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Braze provider in the email channel, you will need to create a [Braze account](https://braze.com/) and add your API key and other credentials to the Braze integration on the Novu platform.

# Generating an API Key

To generate a new API key in Braze, you can follow these steps:

* [Sign up](https://braze.com) or [Log in](https://braze.com) to your Braze account.
* Go to **Settings > API Keys**.
* Click **+ Create New API Key**.
* Give your new key a name for identification at a glance.
* Select the right permission you want to be associated with the new API key.

# Creating a Braze integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-braze) page on Novu.
* Click on `Add a Provider`.
* Locate **Braze** under the Email section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `API Key`.
* Enter the `Base URL`.
* Enter the `From email address`.
* Enter the `Sender name`.
* Click on the **Update** button.


# Custom SMTP
Source: https://v0.x-docs.novu.co/channels-and-providers/email/custom-smtp

Learn how to use the Custom SMTP provider to send email notifications using Novu

You can use a Custom SMTP provider like [Nodemailer](https://nodemailer.com/about/) to send transactional emails through your custom SMTP server to your customers using the Novu Platform with a single API.

# Getting Started

To use the Custom SMTP provider in the email channel, you will need to have your personal SMTP server configured and add `host`, `port`, `user`, and `password` to the Custom SMTP integration on the Novu platform.

You can also provide value **`true`** for the `secure` field if you want the connection to be secure, and if not, leave it empty.

### DKIM (DomainKeys Identified Mail)

DKIM options can be used in order to sign messages sent using Custom SMTP with DKIM keys.

Those options are:

* `DKIM Domain`
* `DKIM Private Key`
* `DKIM Key Selector`

# Creating a Custom SMTP integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-customsmtp) page on Novu.
* Click on Add a Provider.
* Select Custom SMTP service.
* Enter your SMTP credentials
  * `host`
  * `port`
  * `username`
  * `password`
  * `secure` (on demand)
  * And `DKIM` options if you want to sign messages with *DKIM*
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Custom SMTP in Novu.


# Infobip - email
Source: https://v0.x-docs.novu.co/channels-and-providers/email/infobip

Learn how to use the Infobip provider to send email notifications using Novu

You can use the [Infobip](https://www.infobip.com/developers/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Infobip provider in the email channel, you will need to create an Infobip account and add your API key and Base URL to the Infobip integration on the Novu platform.

# Generating an API Key

To generate a new API key in Infobip, you can follow these steps:

* [Sign up](https://www.infobip.com/signup) or [Log in](https://portal.infobip.com/login/) to your Infobip account.
* Navigate to the [Settings](https://portal.infobip.com/settings/accounts/api-keys) of your account and look for the API Keys section at the top of the settings page.

# Creating an Infobip integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-infobip) page on Novu.
* Click on Add a Provider.
* Select Infobip service.
* Enter your Infobip API Key.
* Enter your Base URL.
  * To see your base URL, log in to the account. Once logged in, on all pages, you should see your base URL in this format: `xxxxx.api.infobip.com`.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Infobip in Novu.


# Mailersend
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailersend

Learn how to use the MailerSend provider to send email notifications using Novu

[MailerSend](https://www.mailersend.com/) is an email delivery service that allows you to send emails from your application.

## Getting Started

To use the MailerSend provider in the email channel, you will need to create a MailerSend account and add your API key to the MailerSend integration on the Novu platform. To generate the API token go visit the [MailerSend API Tokens](https://www.mailersend.com/help/managing-api-tokens) page.

## Creating the MailerSend integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mailersend) page on Novu.
* Click on Add a Provider.
* Select MailerSend service.
* Enter the API key.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using MailerSend in Novu.

## Using MailerSend template

Novu has its own email editor for writing email template. If you want to use pre made template from MailerSend, you can use `customData` filed of email overrides to send template details. Make sure your `Api Key` has enough permission to read and process the template.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import {
      Novu
    } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.trigger("workflowIdentifier", {
      to: "subscriberId",
      payload: {},
      overrides: {
        email: {
          customData: {
            // mailersend template templateId
            templateId: 'mailersend-template-id',
            // mailersend template variables
            personalization: [{
              email: 'recipient@email.com',
              data: {
                items: {
                  price: '',
                  product: '',
                  quantity: '',
                },
                order: {
                  date: '',
                  order_number: '',
                  billing_address: '',
                  customer_message: '',
                },
                store: {
                  name: '',
                },
                invoice: {
                  total: '',
                  subtotal: '',
                  pay_method: '',
                },
                customer: {
                  name: '',
                  email: '',
                  phone: '',
                },
              },
            }, ],
          },
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl --location 'https://api.novu.co/v1/events/trigger' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <NOVU_API_KEY>' \
    --data '{
        "name": "workflowIdentifier",
        "to":  ["subscriberId"],
        "payload": {},
        "overrides": {
            "email": {
                "customData": {
                    "templateId": "mailersend-template-id",
                    "personalization": [{
                        "email": "recipient@email.com",
                        "data": {
                            "items": {
                                "price": "",
                                "product": "",
                                "quantity": ""
                            },
                            "order": {
                                "date": "",
                                "order_number": "",
                                "billing_address": "",
                                "customer_message": ""
                            },
                            "store": {
                                "name": ""
                            },
                            "invoice": {
                                "total": "",
                                "subtotal": "",
                                "pay_method": ""
                            },
                            "customer": {
                                "name": "",
                                "email": "",
                                "phone": ""
                            }
                        }
                    }]
                }
            }
        }
    }'
    ```
  </Tab>
</Tabs>


# Mailgun
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailgun

Learn how to use the Mailgun provider to send email notifications using Novu

You can use the [Mailgun](https://mailgun.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Mailgun provider in the email channel, you will need to create a Mailgun account and add your API key and domain name to the Mailgun integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mailgun, you can follow these steps:

* [Sign up](https://signup.mailgun.com/new/signup) or [Log in](https://login.mailgun.com/login/) to your Mailgun account.
* Click on the **Profile** section in the top right corner of the screen, and then click "API Keys" from the drop-down menu.
* On the [API Keys](https://app.mailgun.com/app/account/security/api_keys) page, copy the generated **Private API Key**

# Adding a new domain name

Mailgun recommends that you add a subdomain as a domain name. To do so:

* Visit the page to add a [domain name](https://app.mailgun.com/app/sending/domains/new).
  * During this process, you will need to choose a region for the domain name which is between `US` and `EU`. The default is `US`.
* Follow the [instructions](https://documentation.mailgun.com/en/latest/user_manual.html#verifying-your-domain-1) to verify the domain name.

# Creating a Mailgun integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mailgun) page on Novu.
* Click on Add a Provider.
* Select Mailgun service.
* Enter your Mailgun API Key.
* Enter your Base URL.
  * For domains created in the EU region, the base URL is: `https://api.eu.mailgun.net/`
  * Otherwise, leave the base URL blank.
* Fill in the `Username`.
* Fill in the `Domain name` registered on Mailgun.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Mailgun in Novu.


# Mailjet
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailjet

Learn how to use the Mailjet provider to send email notifications using Novu

You can use the [Mailjet](https://mailjet.com/) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the Mailjet provider in the email channel, you will need to create a Mailjet account and add your API key to the Mailjet integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mailjet, you can follow these steps:

* Log in to your Mailjet account.
* Click on **Settings** in the top-right corner of the screen, and then click **API KEYS & TRACKING** from the drop-down menu.
* On the API Keys page, click the **Create an API Key** button.
* Give the API key a name and choose the access level **Write and Read**
* Click the **Generate Key** button to create the new key. Once generated you can see the key but it will be hidden after the refresh

# Authenticating your sender identity

Before you can send emails on a large scale, you will need to authenticate your Sender identity. This is due to the latest regulatory changes regarding SPAM rules and email fraud. Most of the providers including Mailjet require you to authenticate your Sender identity before you can send emails.

Mailjet allows you to authenticate your sender identity using one of the following methods:

* [Single Sender Verification](https://dev.mailjet.com/email/guides/senders-and-domains/#sender-validation) - This is the easiest way to authenticate your sender identity.
* [Entire Domain Authentication](https://dev.mailjet.com/email/guides/senders-and-domains/#spf-and-dkim-validation) - This is recommended if you are sending emails from multiple accounts under your domain.

# Creating a Mailjet integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mailjet) page on Novu.
* Click on Add a Provider.
* Select Mailjet service.
* Enter your Mailjet API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Mailjet in Novu.


# Mailtrap
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailtrap

Learn how to use the Mailtrap provider to send email notifications using Novu

You can use the [Mailtrap](https://mailtrap.io/email-sending/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Mailtrap provider in the email channel, you will need to create a Mailtrap account and add your API key to the Mailtrap integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mailtrap, you can follow these steps:

* [Sign Up](https://mailtrap.io/register/signup) or [Log in](https://mailtrap.io/signin) to your Mailtrap account.
* Click on the **Email Sending** link on the sidebar, and then click the "Sending Domains" link that pops up from the available options.
* On the [Sending Domains](https://mailtrap.io/sending/domains) page, type your domain name and confirm with the `Add Your Domain` button. Then, proceed to copy DNS records Mailtrap provides to your domain’s DNS.
* Go to [API Keys](https://mailtrap.io/api-tokens) page and copy token with `Domain Admin` access level for your registered domain.

# Authenticating your Sender Identity

Before you can send emails, you will need to [verify your sending domain ownership](https://help.mailtrap.io/article/69-sending-domain-setup). Mailtrap rejects sending emails from unverified domains to prevent spam and email fraud.

# Creating a Mailtrap integration with Novu

* Visit the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-mailtrap) on the Novu web dashboard.
* Click on Add a Provider.
* Select Mailtrap service.
* Enter your Mailtrap API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications through Mailtrap using Novu.


# Mandrill
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mandrill

Learn how to use the Mandrill provider to send email notifications using Novu

You can use the [Mandrill by Mailchimp](https://mandrillapp.com/) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the Mandrill provider in the email channel, you will need to create a Mandrill account and add your API key to the Mandrill integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mandrill, you can follow these steps:

* [Sign up](https://login.mailchimp.com/signup/) or [Log in](https://login.mailchimp.com/) to your Mandrill account.
* Navigate to the [Settings](https://mandrillapp.com/settings) of your account and look for the API Keys section at the bottom of the settings page.
* Click on the **+ Add API Key** button to create an API key. Copy the generated key immediately and store it in a secure location. You won’t be able to see or copy the key once you finish generating it.

# Adding a sending domain

To get started, you’ll need to add the domain that you want to send messages from.

* Navigate to the [Settings page](https://mandrillapp.com/settings/sending-domains) and choose Domains
* Type a new domain in the domain input and click Add
* Follow the instructions to [verify ownership](https://mailchimp.com/developer/transactional/docs/authentication-delivery/#authentication) of your sending domain and [update your DNS records](https://mailchimp.com/developer/transactional/docs/authentication-delivery/#configure-your-dns).

# Creating the Mandrill integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mandrill) page on Novu.
* Click on Add a Provider.
* Select Mandrill service.
* Enter your Mandrill API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Mandrill in Novu.


# Netcore
Source: https://v0.x-docs.novu.co/channels-and-providers/email/netcore

Learn how to use the Netcore provider to send email notifications using Novu

You can use the [Netcore](https://netcorecloud.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Netcore provider in the email channel, you will need to create a Netcore account and add your API key to the Netcore integration on the Novu platform.

# Generating an API Key

To generate a new API key in Netcore, you can follow these steps:

* [Log in](https://email.netcorecloud.com/) to your Netcore account.
* Go to the **Integration** page under the **Settings** menu and click on the **API** tab.
* The API Key is hidden for security purposes. Click Show. The system will prompt you to enter your account password. Once you enter the password, the API key will be accessible.

# Setting up sending domains

To start sending emails, you need to add and verify your sending domains. You can either use your top-level domain (e.g. my-company.com) or a sub-domain like email.my-company.com. The verification is done to ensure your sending domain’s security.

Follow the instructions on this [page](https://emaildocs.netcorecloud.com/docs/what-is-a-sending-domain-how-to-set-up-sending-domains) to get started

# Creating a Netcore integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-netcore) page on Novu.
* Click on Add a Provider.
* Select Netcore service.
* Enter your Netcore API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Netcore in Novu.


# Outlook 365
Source: https://v0.x-docs.novu.co/channels-and-providers/email/outlook365

Learn how to use the Outlook 365 provider to send email notifications using Novu

You can use the [Outlook 365](https://office.com/) provider to send transactional emails through your instance of Office 365 to your customers using the Novu Platform with a single API.

## Getting Started

To use the Outlook 365 provider in the email channel, you will need to have the sender's email (user) and the password for the account. This account cannot be a shared mailbox or distribution list. It will need to be properly licensed to send email via Office 365.

## Creating the Outlook 365 integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-office365) page on Novu.
* Click on Add a Provider.
* Select Outlook service.
* Enter your SMTP credentials
  * `from`: The Complete email address of the sending user. (e.g. [jdoe@mycompany.com](mailto:jdoe@mycompany.com))
  * `senderName`: Sender Name should be the same email address of the sending user. (e.g. [jdoe@mycompany.com](mailto:jdoe@mycompany.com))
  * `password`: Password used to sign in with the email account.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Outlook 365 in Novu.

<Note> In order to create outlook integration, turn off multi factor authentication from account security settings.</Note>


# Email providers
Source: https://v0.x-docs.novu.co/channels-and-providers/email/overview

Learn the process of configuring email providers with Novu

Novu can be used to deliver email messages to your customers using a unified delivery API. You can easily integrate your favorite email provider using the built-in integration store.

<iframe />

## Configuring email providers

When creating an email provider integration you will be asked to provide additional fields alongside the provider-specific credentials:

* **Sender name** - Will be displayed as the sender of the message
* **From email address** - Emails sent using Novu will be sent using this address

For some email providers including SendGrid you will have to authenticate the **From email address** to make sure you will send email messages using an authorized address.

## Sending Email Overrides

The overrides field supports an email property. The email overrides field have properties like `to`, `from`, `senderName` etc

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        email: {
          to: ['to@novu.co'],
          from: 'from@novu.co',
          senderName: 'Novu Team',
          text: 'text version of email using overrides',
          replyTo: 'no-reply@novu.co',
          cc: ['1@novu.co'],
          bcc: ['2@novu.co'],
        },
      },
    });
    ```
  </Tab>
</Tabs>

<Note>It's very important to know that Novu merges the `to` field in the email overrides with the subscriber email. It DOES NOT REPLACE IT.</Note>

### Overriding the selected layout

Layout can be selected in the email step editor. To use another layout with emails, selected layout can be overridden using layoutIdentifier in the overrides field.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        layoutIdentifier: 'layout-identifier-value',
      },
    });
    ```
  </Tab>
</Tabs>

## Sending Email attachments

You can easily send attachments with the Novu API by passing the attachments array when triggering an Email based workflow. Attachment file can either be in the `buffer` or `base64` format.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      payload: {
        attachments: [
          {
            file: fs.readFileSync(__dirname + '/data/novu.jpeg'),
            name: 'novu.jpeg',
            mime: 'image/jpeg',
          },
        ],
      },
    });
    ```
  </Tab>
</Tabs>

## Using different email integration

In Novu integration store, multiple email channel type provider integrations can be active at the same time. But only one  provider integration can be primary at a time. This primary integration will be used as a provider to deliver the email by default. If you want to use a different active provider integration then you can use the `integrationIdentifier` email overrides field.

If there are 4 active email integrations with these identifiers:-

1. sendgrid-abcdef
2. sendgrid-ghijkl
3. brevo-abcdef
4. mailersend-abcdef

Here, if `sendgrid-abcdef` is primary integration and you want to use `brevo-abcdef` with this trigger then you can use `integrationIdentifier` email overrides field as below:-

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        email: {
          integrationIdentifier: "brevo-abcdef"
        },
      },
    });
    ```
  </Tab>
</Tabs>

<Info> Integration identifier is similar to Provider identifier but it is different than Provider Id. It is unique for each integration.You can find the `integrationIdentifier` in the integration store page.  </Info>

<Tip>
  <MissingProvider />
</Tip>


# Plunk
Source: https://v0.x-docs.novu.co/channels-and-providers/email/plunk

Learn how to use the Plunk provider to send email notifications using Novu

You can use the [Plunk](https://useplunk.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Plunk provider in the email channel, you will need to create a Plunk account and add your API key to the Plunk integration on the Novu platform.

## Get API Key

To generate a new API key in Plunk, you can follow these steps:

* Log in to your Plunk account.
* Click on `Project Settings` on the side bar and then `API keys` on the tab.
* On the API Keys page, click on `Secret API key` to copy.

## Authenticate your sender identity

Before you can send emails on a large scale, you will need to authenticate your Sender Identity. Plunk allows you to authenticate your sender identity using [Domain Authentication](https://app.useplunk.com/settings/identity)

## Create a Plunk integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-plunk) page on Novu.
* Click on Add a Provider.
* Select Plunk service.
* Enter your Plunk secret API Key.
* Fill the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Plunk in Novu.


# Postmark
Source: https://v0.x-docs.novu.co/channels-and-providers/email/postmark

Learn how to use the Postmark provider to send email notifications using Novu

It is possible to use [Postmark](https://postmarkapp.com/) as a provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

The first step to use the Postmark provider in the email channel is to create a Postmark account and add the personal API key to the Postmark integration on the Novu platform.

# Getting the API Key

* To find the Postmark API key, log into the personal Postmark account and navigate to the servers page.
* After selecting the server to use, the API key (referred to as "Server API tokens") will be in the "API Tokens" section of the server chosen.

# Authenticating the sender's identity

Due to the latest regulatory changes regarding SPAM rules and email fraud, it is needed to authenticate the sender's identity before sending emails on a large scale. Most of the providers, including Postmark, require authentication to unlock the possibility of sending emails.

Postmark allows the authentication of the sender's identity using one of the following methods:

* [Single Sender Verification](https://account.postmarkapp.com/signatures/new) - This is the easiest way to authenticate the sender's identity.
* [Entire Domain Authentication](https://postmarkapp.com/support/article/1046-how-do-i-verify-a-domain#:~:text=be%20verified%20automatically.-,Navigate%20to%20Sender%20Signatures.,to%20your%20DNS%2C%20choose%20Verify.) - This is recommended for sending emails from multiple accounts under the same domain.

# Create a Postmark integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-postmark) page on Novu.
* Click on Add a Provider.
* Select Postmark service.
* Enter the Postmark API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* Now is possible to send notifications using Postmark in Novu.


# Resend
Source: https://v0.x-docs.novu.co/channels-and-providers/email/resend

Learn how to use the Resend provider to send email notifications using Novu

You can use the [Resend](https://resend.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Resend provider in the email channel, you will need to create a Resend account and add your API key to the Resend integration on the Novu platform.

# Generating an API Key

To generate a new API key in Resend, you can follow these steps:

* [Sign up](https://resend.com/secret) or [Log in](https://resend.com/login) to your Resend account.
* Click on the **API Keys** link in the left sidebar, and then click the "Create API Key" button on the top right part of the page.
* On the [API Keys](https://resend.com/api-keys) page, click the **Create API Key** button.
* Give the API key a name and click on the **Add** button.
* Copy the generated API Key.

# Authenticating your Sender Identity

Before you can send emails on a large scale, you will need to authenticate your Sender Identity.

Resend allows you to authenticate your sender identity using [Domain Authentication](https://resend.com/docs/dashboard/domains/introduction).

# Creating a Resend integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-resend) page on Novu.
* Click on Add a Provider.
* Select Resend service.
* Enter your Resend API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
  * For testing, you can use `onboarding@resend.dev` if you have not authenticated your sender identity.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Resend in Novu.


# SendGrid
Source: https://v0.x-docs.novu.co/channels-and-providers/email/sendgrid

Learn how to use the Sendgrid provider to send email notifications using Novu

You can use the [SendGrid](https://sendgrid.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Sendgrid provider in the email channel, you will need to create a Sendgrid account and add your API key to the SendGrid integration on the Novu platform.

## Generating an API Key

To generate a new API key in SendGrid, follow these steps:

* Log in to your SendGrid account.
* Click on the **Settings** gear icon in the top right corner of the screen, and then click "API Keys" from the drop-down menu.
* On the API Keys page, click the **Create API Key** button.
* Give the API key a name and select the following permissions
* **Mail Send** - Full Access
* (Optional) Template Engine - Read Only
* Click the **Create & View** button to generate the API key. The key will be displayed on the screen, but you will only be able to view it once, so make sure to save it in a safe place.

NOTE

The access level of the key will determine what actions the API Key can take, so please choose the correct one.

* **Mail Send** - Full Access
* (Optional) Template Engine - Read Only

## Authenticating your [Sender Identity](https://docs.sendgrid.com/for-developers/sending-email/sender-identity)

Before you can send emails on a large scale, you will need to authenticate your Sender Identity. This is due to the latest regulatory changes regarding SPAM rules and email fraud. Most of the providers including Sendgrid require you to authenticate your Sender Identity before you can send emails.

SendGrid allows you to authenticate your sender identity using one of the following methods:

* [Single Sender Verification](https://docs.sendgrid.com/ui/sending-email/sender-verification) - This is the easiest way to authenticate your sender identity.
* [Entire Domain Authentication](https://docs.sendgrid.com/ui/account-and-settings/how-to-set-up-domain-authentication) - This is recommended if you are sending emails from multiple accounts under your domain.

## SendGrid integration with Novu

* Visit the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-sendgrid) on the Novu web dashboard.
* Click on Add a Provider.
* Select SendGrid service.
* Enter your SendGrid API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications through SendGrid using Novu.

## Using SendGrid template

Novu has its own email editor for writing email template. If you want to use pre made template from SendGrid, you can use `customData` filed of email overrides to send template details. Make sure your `Api Key` has enough permission to read and process the template.

<Info>customData override is available from version 0.21.0</Info>

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.trigger("workflowIdentifier", {
      to: "subscriberId",
      payload: {},
      overrides: {
        email: {
          customData: {
            // sendgrid template templateId
            templateId: 'sendgrid-template-id',
            // sendgrid template variables
            dynamicTemplateData: {
              total: '$ 239.85',
              items: [{
                  text: 'New Line Sneakers',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png',
                  price: '$ 79.95',
                },
                {
                  text: 'Old Line Sneakers rlfjrjrh4hr4rh4',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png',
                  price: '$ 79.95',
                },
              ],
              receipt: true,
              name: 'Sample Name',
              address01: '1234 Fake St.',
              address02: 'Apt. 123',
              city: 'Place',
              state: 'CO',
              zip: '80202',
            },
          },
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl --location 'https://api.novu.co/v1/events/trigger' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <NOVU_API_KEY>' \
    --data '{
        "name": "workflowIdentifier",
        "to":  ["subscriberId"],
        "payload": {},
        "overrides": {
            "email": {
                "customData": {
                    "templateId": "sendgrid-template-id",
                    "dynamicTemplateData": {
                        "total": "$ 239.85",
                        "items": [
                            {
                                "text": "New Line Sneakers",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png",
                                "price": "$ 79.95"
                            },
                            {
                                "text": "Old Line Sneakers rlfjrjrh4hr4rh4",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png",
                                "price": "$ 79.95"
                            }
                        ],
                        "receipt": true,
                        "name": "Sample Name",
                        "address01": "1234 Fake St.",
                        "address02": "Apt. 123",
                        "city": "Place",
                        "state": "CO",
                        "zip": "80202"
                    }
                }
            }
        }
    }'
    ```
  </Tab>
</Tabs>


# Sendinblue
Source: https://v0.x-docs.novu.co/channels-and-providers/email/sendinblue

Learn how to use the Sendinblue provider to send email notifications using Novu

You can use the [Sendinblue](https://www.sendinblue.com/) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the Sendinblue provider in the email channel, you will need to create a Sendinblue account and add your API key to the Sendinblue integration on the Novu platform.

# Finding the API Key

* To find your Sendinblue API key, log into your Sendinblue account and navigate to the [API Keys](https://account.sendinblue.com/advanced/api) page.

# Authenticating your sender identity

Before you can send emails on a large scale, you will need to authenticate your sender's identity. This is due to the latest regulatory changes regarding SPAM rules and email fraud. Most of the providers including Sendinblue require you to authenticate your sender identity before you can send emails.

Sendinblue allows you to authenticate your sender identity using one of the following methods:

* [Single Sender Verification](https://account.sendinblue.com/senders) - This is the easiest way to authenticate your sender identity.
* [Entire Domain Authentication](https://help.sendinblue.com/hc/en-us/articles/115000185270-What-is-a-verified-domain-on-Sendinblue-) - This is recommended if you are sending emails from multiple accounts under your domain.

# Creating a Sendinblue integration with Novu

* Visit the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-sendinblue) on the Novu web dashboard.
* Click on Add a Provider.
* Select Sendinblue service.
* Enter your Sendinblue API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Sendinblue in Novu.

## Using Sendinblue template

Novu has its own email editor for writing email template. If you want to use pre made template from Sendinblue, you can use `customData` filed of email overrides to send template details. Make sure your `Api Key` has enough permission to read and process the template.

<Info>customData override is available from version 0.21.0</Info>

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.trigger("workflowIdentifier", {
      to: "subscriberId",
      payload: {},
      overrides: {
        email: {
          customData: {
            // sendinblue template templateId
            templateId: 1,
            // sendinblue template variables
            templateParams: {
              total: '$ 239.85',
              items: [{
                  text: 'New Line Sneakers',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png',
                  price: '$ 79.95',
                },
                {
                  text: 'Old Line Sneakers rlfjrjrh4hr4rh4',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png',
                  price: '$ 79.95',
                },
              ],
              receipt: true,
              name: 'Sample Name',
              address01: '1234 Fake St.',
              address02: 'Apt. 123',
              city: 'Place',
              state: 'CO',
              zip: '80202',
            },
          },
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId",
      tenant: "tenantIdentifier"
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl --location 'https://api.novu.co/v1/events/trigger' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <NOVU_API_KEY>' \
    --data '{
        "name": "workflowIdentifier",
        "to":  ["subscriberId"],
        "payload": {},
        "overrides": {
            "email": {
                "customData": {
                    "templateId": 1,
                    "templateParams": {
                        "total": "$ 239.85",
                        "items": [
                            {
                                "text": "New Line Sneakers",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png",
                                "price": "$ 79.95"
                            },
                            {
                                "text": "Old Line Sneakers rlfjrjrh4hr4rh4",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png",
                                "price": "$ 79.95"
                            }
                        ],
                        "receipt": true,
                        "name": "Sample Name",
                        "address01": "1234 Fake St.",
                        "address02": "Apt. 123",
                        "city": "Place",
                        "state": "CO",
                        "zip": "80202"
                    }
                }
            }
        }
    }'
    ```
  </Tab>
</Tabs>


# Sparkpost
Source: https://v0.x-docs.novu.co/channels-and-providers/email/sparkpost

Learn how to use the Sparkpost provider to send email notifications using Novu

You can use the [SparkPost](https://messagebird.com/email/cloud-sending) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the SparkPost provider in the email channel, you will need to create a SparkPost account and add your API key to the SparkPost integration on the Novu platform.

# Generating an API Key

To generate a new API key in SparkPost, you can follow these steps:

* [Sign up](https://app.sparkpost.com/join) or [Log in](https://app.sparkpost.com/auth) to your SparkPost account.

  > During sign up, note that SparkPost is available in multiple regions. "SparkPost" refers to the SparkPost service hosted in North America. "SparkPost EU" refers to the SparkPost service hosted in Western Europe. An account created with SparkPost cannot be used with SparkPost EU, and vice-versa. You may use accounts in both regions.
  >
  > \~ *[SparkPost Documentation](https://support.sparkpost.com/docs/getting-started/getting-started-sparkpost/)*
* Click on the **Configuration** link on the navbar, and then click the "API Keys" link that pops up from the available options.
* On the [API Keys](https://app.sparkpost.com/account/api-keys) page, click the **Create API Key** button.
* Give the API key a name and click on the **Create API key** button.
* Copy the generated API Key.

# Authenticating your Sender Identity

Before you can send emails on a large scale, you will need to authenticate your Sender Identity.

SparkPost allows you to authenticate your sender identity using [Sending Domains](https://app.sparkpost.com/domains/list/sending).

# Creating a SparkPost integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sparkpost) page on Novu.
* Click on Add a Provider.
* Select SparkPost service.
* Enter your SparkPost API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Toggle the `eu` switch to true if you're in Western Europe
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using SparkPost in Novu.


# Introduction
Source: https://v0.x-docs.novu.co/channels-and-providers/in-app/introduction

Learn how to integrate In-App notification center and send In-App notification using Novu

In-app notifications are messages or alerts that appear within a mobile app or website while a user is actively using it. Unlike push notifications, which can reach users even when they're not actively engaged with an app, in-app notifications are designed to enhance the user experience within the app itself. Here's why they are important:

1. User Engagement: In-app notifications can keep users engaged and informed while they are using your app, providing valuable updates, reminders, or information relevant to their current activity. This can improve user satisfaction and encourage them to spend more time within the app.

2. Personalization: In-app notifications can be highly personalized based on a user's behavior, preferences, or location within the app. This personalization can lead to a more tailored and relevant user experience, increasing the likelihood of conversions or desired actions.

3. Onboarding and Education: In-app notifications are useful for guiding users through the app's features and functions, helping newcomers understand how to use the app effectively. They can also provide tips, tutorials, and educational content to enhance user proficiency.

4. Feedback and Surveys: In-app notifications can prompt users to provide feedback, complete surveys, or rate the app. Gathering user feedback within the app allows for real-time insights and improvements, contributing to app quality and user satisfaction.

5. Transactional Updates: In e-commerce or service apps, in-app notifications are crucial for providing order confirmations, shipping updates, payment receipts, and other transaction-related information, ensuring users are kept informed about important actions they've taken within the app.

6. Reduced Interruption: Unlike push notifications, in-app notifications are less intrusive since they only appear when users are actively engaged with the app. This can lead to a more seamless and focused user experience.

7. User Retention: By delivering timely and relevant information, in-app notifications can help retain users and reduce churn rates. Users who find value in the app are more likely to continue using it over time.

8. A/B Testing and Optimization: In-app notifications can be A/B tested to determine which messages and designs are most effective in achieving specific goals, such as increasing conversions or user engagement.

## In-app notifications using Novu

<iframe />

Novu provides a pre built component to display in-app notifications for almost all web frameworks. You can use this component to display in-app notifications in your web app. If you don't want to use the pre built component, you can use the headless component to build your own in-app notification center. Read more about notification center [here](/notification-center/introduction).


# Integration Store
Source: https://v0.x-docs.novu.co/channels-and-providers/integration-store

Learn about Novu's integration store

## Introduction

Novu's integration store serves as the central hub from where you can seamlessly enable and disable various services for efficient communication.

This feature simplifies the process of managing your communication channels. You can see which provider is enabled/disabled for what channel, which provider works in what environment and more. Moreover, it provides a clear overview of enabled and disabled services, offering you greater control over your communication strategy.

<Frame>
  <img />
</Frame>

From this image above, you can see that I've configured `Sendgrid` and `Twilio` as my email and sms provider respectively and both are in the `development` environment.

## Streamline Communication Services

With the Integration Store, you can streamline your communication services effortlessly. Whether it's Email, Chat, or SMS, this feature allows you to integrate different communication channels with ease. This centralization ensures that you can manage all your services conveniently from a single location.

## Enabling and Disabling Services

The Integration Store allows you to activate or deactivate specific services according to your communication needs. You can enable a service by simply entering the required `API key`, `identifier` and other required info depending on the provider you're choosing. Conversely, if you need to deactivate a service temporarily or make changes, you can disable it just as effortlessly.

## Enhanced Flexibility

By providing a comprehensive range of communication services under one roof, the Integration Store enhances your flexibility. You have the power to customize your communication strategy by enabling the services that align with your requirements.

## Conclusion

Novu's integration store offers a centralized and user-friendly platform for managing your communication services effectively. With its categorization, clear visibility, and easy enablement/disabling of services, you can fine-tune your communication strategy and streamline your interactions, enhancing the overall communication experience of your product.


# Overview
Source: https://v0.x-docs.novu.co/channels-and-providers/introduction

Learn about what channels, providers and oganizations are

## Channels:

Novu lets you send notifications across different communication mediums, including emails, in-app messages, push notifications, SMS, and chat. Each of these five communication mediums is referred to as a notification ‘channel’.

<Frame>
  <img />
</Frame>

## Providers:

Providers are what allow us to handle message delivery over multiple channels. Of the five notification channels that Novu currently supports, each channel except the ‘in-app’ channel has multiple providers.

The in-app channel only has one provider (the default Novu provider).

All the remaining channels have multiple providers.

## Organizations:

Organizations enable you to segregate notifications across multiple products that you may have. You can use Novu to send notifications across multiple apps and can create organizations.

<Frame>
  <img />
</Frame>

<Warning>Credentials are saved per instance of the active integrations of a provider. In case of more than one active provider of the same type, If `integrationIdentifier` is not sent in [this](https://docs.novu.co/api-reference/subscribers/update-subscriber-credentials) API, then the most recently created provider will be used to update the credentials.</Warning>


# Africa's Talking
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/africas-talking

Learn how to use the Africa's Talking provider to send sms notifications using Novu

You can use [Africa's Talking](https://africastalking.com/) provider to send SMS messages to your customers using the Novu platform with a single API to create multi-channel experiences.

## Getting Started

To use Africa's Talking provider in the SMS channel, the first step is to create an Africa's Talking account and add your `API Key`, `username` and `Sender's ID` to Africa's Talking integration on the Novu platform.

## Creating a username

You’ll need to create an application to create a username in Africa’s Talking. To do so, follow the steps below:

* [Sign up](https://account.africastalking.com/auth/register) or [Log in](https://account.africastalking.com/auth/login) to your Africa's Talking account.
* Select the team you want your app to be in.

<Frame>
  <img />
</Frame>

* If you're a new user and don't have a team yet, you'll have to do so by clicking on New Team and entering your team name. Click on Save when you're done.

<Frame>
  <img />
</Frame>

* On the page that appears, click on the Create App button.
* On the pop-up that appears, enter your application name, username and select a country. Then click Save. The `username` is what you will use on the Novu platform.

<Frame>
  <img />
</Frame>

## Generating an API key

To generate a new API key, you can follow these steps:

<Note>
  Ensure you have created an app in your team.
</Note>

* Click on the app you created.

<Frame>
  <img />
</Frame>

* On the page that appears, click on Settings(on the menu on your left). This will display a dropdown. Click on API Key from the dropdown options.

<Frame>
  <img />
</Frame>

* On the page that appears, enter your password and click Generate.

<Frame>
  <img />
</Frame>

* Copy the API Key generated and paste it into the Novu platform or record it somewhere safe for later use because you will not see it from the dashboard on subsequent visits.

<Note>
  Once you've generated your API Key, wait about 3 minutes before testing it.
</Note>

## Getting your Sender's ID

Sender IDs allow you to brand your messages as you send them to your customers. There are two kinds of sender IDs, **shortcodes** and **alphanumerics**. The difference is that you can send and receive messages with shortcodes but only send messages with an alphanumeric.

To create a Short Code:

* On your app dashboard, click on SMS (on the menu on your left). This will display a dropdown. Click on `Shortcodes` from the dropdown options. This will also display a dropdown from which you can then click on `My Shortcodes` to view your codes.

<Frame>
  <img />
</Frame>

* If you have not created one yet, on the `Shortcodes` dropdown option, click on `Request`.
  On the page that appears, fill in the form and submit.

<Frame>
  <img />
</Frame>

## To create an Alphanumeric:

* On your app dashboard, click on SMS (on the menu on your left). This will display a dropdown. Click on `Alphanumerics` from the dropdown options. This will also display a dropdown from which you can then click on `My Alphanumerics` to view your codes.

<Frame>
  <img />
</Frame>

* If you have not created one yet, on the `Alphanumerics` dropdown option, click on `Request`.
  On the page that appears, fill in the form and submit

<Frame>
  <img />
</Frame>

* Once you're done, add either your short code or alphanumeric to the `from` field on the Novu platform.

## Creating an Africa's Talking integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-africastalking) page on Novu.
* Click the "Add a provider" button.
* Locate **Africa's Talking** under the SMS section and click on the **Connect** button.
* Enter the `API key`.
* Fill in the `username` field.
* Fill in the `from` field. This is your registered `short code` or `alphanumeric` value.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using Africa's Talking in Novu.


# AWS SNS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/aws-sns

Learn how to use the AWS SNS provider to send sms notifications using Novu

You can use the [AWS SNS](https://aws.amazon.com/sns/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To integrate AWS SNS on the Novu platform, you will need to have in AWS, an IAM user who has the `sns:Publish` permission.

# Create User

To create a user, log in to AWS Console and follow these steps:

* Go to the `IAM` service page.
* Create a new user with `sns:Publish` permission, or add `sns:Publish` permission to an existing user.
* Add the `Access Key` credential to the user and copy the `Access key ID` and the `Secret access key`.

For security reasons, it is suggested that you create a new User to use with Novu.

# Create an AWS SNS integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-sns) page on Novu.
* Click the "Add a provider" button.
* Locate **Amazon SNS** and click on the **Connect** button.
* Enter your `Access Key ID`, `Secret Access key`, and `AWS region`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Save** button.
* You should now be able to send SMS notifications using **Amazon SNS** in Novu.


# Azure SMS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/azure

Learn how to use the Azure SMS provider to send sms notifications using Novu

You can use the [Azure SMS](https://learn.microsoft.com/en-us/azure/communication-services/quickstarts/sms/send?tabs=windows\&pivots=platform-azcli) SMS provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use Azure SMS provider in the SMS channel, the first step is to create an Azure account and grab the communication services connection string from your account dashboard.

# Creating a Azure SMS integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-azure) page on Novu.
* Click the "Add a provider" button.
* Locate **Azure Sms** under the SMS section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `Connection string`.
* Enter the `From` value.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **Azure Sms** in Novu.


# BulkSMS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/bulk-sms

Learn how to use the BulkSMS provider to send sms notifications using Novu

You can use the [BurstSMS](https://bulksms.com/) provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use BulkSMS provider in the SMS channel, the first step is to create a BulkSMS account and create an [API token](https://www.bulksms.com/account/#!/advanced-settings/api-tokens).

# Creating a BulkSMS integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-bulksms) page on Novu.
* Click the "Add a provider" button.
* Locate **BulkSMS** under the SMS section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `API Token`.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **BulkSMS** in Novu.


# Clickatell
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/clickatell

Learn how to use the Clickatell provider to send sms notifications using Novu

You can use the [Clickatell](https://www.clickatell.com/) provider to send SMS messages to your customers using the Novu Platform.
Let's see how to do it:

## Getting Started

To use the [Clickatell](https://www.clickatell.com/) provider in the SMS channel, the first step is to [create a Clickatell account](https://www.clickatell.com/sign-up/) and add your API key to the Clickatell integration on the [Novu web dashboard](https://web.novu.co/integrations?utm_campaign=docs-sms-clickatell).

## Retrieving your API Key

To find your Clickatell API key:

* [Sign up](https://www.clickatell.com/sign-up/) or [Login](https://app.clickatell.com/signin) to your Clickatell account.
* Click on the `My Workspace`, and then click `SMS` in Channels Section.

<Frame>
  <img />
</Frame>

* Click on the `New SMS Setup`.

<Frame>
  <img />
</Frame>

* Select `API` then `Messaging Type` and click Next.

<Frame>
  <img />
</Frame>

* Select `Basic HTTP API` then `create a new HTTP API` and click Next.

<Frame>
  <img />
</Frame>

* Now fill in all details and Click Next.

<Frame>
  <img />
</Frame>

* Copy the API key and click complete.

<Frame>
  <img />
</Frame>

## Create a Clickatell integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-clickatell) page on Novu.
* Click the "Add a provider" button.
* Locate **Clickatell** under the SMS section and click on the **Connect** button.
* Enter your Clickatell API Key.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Clickatell** in Novu.


# Firetext
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/firetext

Learn how to use the firetext provider to send sms notifications using Novu

You can use the [firetext](https://www.firetext.co.uk) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the firetext provider in the SMS channel, the first step is to create a firetext account and add your API key and Sender ID to the firetext integration on the Novu platform.

* Note : Firetext is only available in uk region. Others may require additional verification.

## Retrieving your API Key

To find your firetext API key:

* [Sign up](https://app.firetext.co.uk/signup) or [Login](https://app.firetext.co.uk/) to your firetext account.
* Click on the `Settings` icon in the top right corner of the screen.

<Frame>
  <img />
</Frame>

* Now Click on the `API` in `My Settings` Section.

<Frame>
  <img />
</Frame>

* On the API Keys page, copy the `API key`.

<Frame>
  <img />
</Frame>

## Create a firetext integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-firetxt) page on Novu.
* Click the "Add a provider" button.
* Locate **firetext** under the SMS section and click on the **Connect** button.
* Enter your `firetext` API Key.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **firetext** in Novu.


# gupshup
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/gupshup

Learn how to use the gupshup provider to send sms notifications using Novu

You can use the [gupshup](https://www.gupshup.io/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the gupshup provider in the SMS channel, the first step is to create a gupshup account and add the Account Username and Password to the gupshup integration on the Novu platform.

# What is User id and Password?

* `userid` : The account number provided by the Enterprise SMS GupShup.
* `Password` : Password is provided by Gupshup for authentication of user id. The password must be the same as used to log on to the Enterprise SMS GupShup website.

# Creating a gupshup integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-gupshup) page on Novu.
* Click the "Add a provider" button.
* Locate **gupshup** under the SMS section and click on the **Connect** button.
* Enter the `User id`.
* Enter the `Password`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **gupshup** in Novu.


# Infobip - SMS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/infobip

Learn how to use the Infobip provider to send sms notifications using Novu

You can use the [Infobip](https://www.infobip.com/developers/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Infobip provider in the SMS channel, you will need to create an Infobip account and add your API key and Base URL to the Infobip integration on the Novu platform.

## Retrieving your API Key

To Find a new API key in Infobip, you can follow these steps:

* [Sign up](https://www.infobip.com/signup) or [Log in](https://portal.infobip.com/login/) to your Infobip account.
* On the [Homepage](https://portal.infobip.com/homepage/), you'll see your API key.

<Frame>
  <img />
</Frame>

Alternatively, you can find the API key on the Developer Tools page.

* On the sidebar (on the left), click on `Developer Tools`.
* This will display a dropdown from which you can then click on `API Ksys` to view your API key.

<Frame>
  <img />
</Frame>

If you want to create an API key:

* Click on the `CREATE API KEY` button
* Fill the form
* Click on `GENERATE`

<Frame>
  <img />
</Frame>

## Finding the Base URL

To see your base URL, log in to the account. Once logged in, on the Homepage, you should see your base URL in this format: `xxxxx.api.infobip.com`.

<Frame>
  <img />
</Frame>

## Create an Infobip integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-infobip) page on Novu.
* Click the "Add a provider" button.
* Locate **Infobip** under the SMS section and click on the **Connect** button.
* Enter your Infobip API Key.
* Enter your Base URL.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

You should now be able to send SMS notifications using Infobip in Novu.


# MessageBird
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/messagebird

Learn how to use the messagebird provider to send sms notifications using Novu

You can use the [MessageBird](https://www.messagebird.com) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the MessageBird provider in the SMS channel, the first step is to create a [MessageBird account](https://www.messagebird.com/en/sign-up) and then generate an `Access Key` within the developers' section section of your MessageBird account. This access key is essential for authenticating your requests to the MessageBird API.

# Creating a MessageBird integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-messagebird) page on Novu.
* Click the "Add a provider" button.
* Locate **MessageBird** under the SMS section. Click it and the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `Access Key` value.
* Enter the `From` value.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **MessageBird** in Novu.


# Nexmo
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/nexmo

Learn how to use the Nexmo provider to send sms notifications using Novu

You can use the [Nexmo By Vonage](https://www.vonage.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Nexmo provider in the SMS channel, the first step is to create a Nexmo account and add the API key and API Secret to the Nexmo integration on the Novu platform.

# Finding the API key and secret

First, [sign up for a Vonage account](https://ui.idp.vonage.com/ui/auth/login) if you don't already have one, and make a note of your API key and secret on the [dashboard getting started page](https://dashboard.nexmo.com/getting-started-guide).

# Create a Nexmo integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-nexmo) page on Novu.
* Click the "Add a provider" button.
* Locate **Nexmo** under the SMS section and click on the **Connect** button.
* Enter the `API key` and `API Secret`.
* Enter a valid `From` email address.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.
* Now it is possible to send SMS notifications using **Nexmo** in Novu.


# SMS Channel Overview
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/overview

Learn the process of configuring and using sms providers with Novu

Novu can be used to deliver sms messages to your customers using a unified delivery API. You can easily integrate your favorite sms provider using the built-in integration store.

<iframe />

## Configuring SMS providers

When creating a SMS provider integration you will be asked to provide additional fields alongside the provider-specific credentials:

* **From** - Will be displayed as the sender of the SMS

Additional credentials can be API key, username, password or other provider specific credentials.

<Note>
  Some countries have strict restriction of using verified `from` sender id
  (name). Kindly check country and provider specific requirements first.
</Note>

## Sending SMS Overrides

The overrides field supports a `sms` property and `from`, `to`, `content` field overrides. This allows you to send a message to a different recipient, from a different sender, or with a different content.

```javascript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  }
  overrides: {
    sms: {
      to: '+123012345678',
      from: 'Novu Team',
      content: 'This SMS message is from overrides'
    },
  },
});
```

## Using different SMS integration

In Novu integration store, multiple SMS channel type provider integrations can be active at the same time. But only one provider integration can be primary at a time. This primary integration will be used as a provider to deliver the SMS by default. If you want to use a different active provider integration then you can use the `integrationIdentifier` sms overrides field.

If there are 4 active SMS integrations with these identifiers:-

1. twilio-abcdef
2. twilio-ghijkl
3. firetext-abcdef
4. infobip-abcdef

Here, if `twilio-abcdef` is primary integration and you want to use `infobip-abcdef` with this trigger then you can use `integrationIdentifier` sms overrides field as below:-

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        sms: {
          integrationIdentifier: "infobip-abcdef"
        },
      },
    });
    ```
  </Tab>
</Tabs>

<Info> Integration identifier is similar to Provider identifier but it is different than Provider Id. It is unique for each integration. You can find the `integrationIdentifier` in the integration store page.  </Info>

## Common errors

Common errors and reason for these errors while sending sms messages using Novu.

1. Subscriber does not have a configured channel.
   * if the `from` field is missing / null / undefined.

<Tip>
  <MissingProvider />
</Tip>


# Plivo
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/plivo

Learn how to use the Plivo provider to send sms notifications using Novu

You can use the [Plivo](https://www.plivo.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Plivo provider in the SMS channel, the first step is to create a Plivo account and add the Account SID and Auth token to the Plivo integration on the Novu platform.

# Finding the Account SID and Auth token

[Sign up](https://console.plivo.com/accounts/register/) or [Login](https://console.plivo.com/accounts/login/) to your Plivo account, and make a note of your Account SID and Auth token on the [Plivo console page](https://console.plivo.com/dashboard/).

# Creating a Plivo integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-plivo) page on Novu.
* Click the "Add a provider" button.
* Locate **Plivo** under the SMS section and click on the **Connect** button.
* Enter the `Account SID`.
* Enter the `Auth token`.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Plivo** in Novu.


# Sendchamp
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/sendchamp

Learn how to use the Sendchamp provider to send sms notifications using Novu

You can use the [Sendchamp](https://www.sendchamp.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Sendchamp provider in the SMS channel, the first step is to create a Sendchamp account and add your API key and Sender ID to the Sendchamp integration on the Novu platform.

## Retrieving your API Key

To find your Sendchamp API key:

* [Sign up](https://my.sendchamp.com/signup) or [Login](https://my.sendchamp.com/login) to your Sendchamp account.
* Click on the Avatar icon in the top right corner of the screen, and then click `API & Integrations` from the drop-down menu.

<Frame>
  <img />
</Frame>

Alternatively, you can access the API key from the Accounts menu.

* Scroll to the bottom of the sidebar (on the left) and click on `Accounts`.
* This will display a dropdown from which you can then click on `API keys & Webhooks` to view your API key.

<Frame>
  <img />
</Frame>

* On the API Keys page, copy the Public access key.

<Frame>
  <img />
</Frame>

## Get your Sender's ID

The Sender ID represents the sender of the message to your customers.

To get your Sender's ID:

* On the sidebar (on the menu on your left), click on `SMS`. This will display a dropdown. Click on `Sender ID` from the dropdown options.
* On the page that appears, you'll find a list of your Sender IDs

<Frame>
  <img />
</Frame>

If you have not created one yet:

* Click on the `Create Sender ID` button to request a Sender ID.
* Fill in the form.
* Click on `Add Sender ID` button.

<Frame>
  <img />
</Frame>

Once it is approved, you can use your Sender ID as the from field on the Novu platform.

## Create a Sendchamp integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-sendchamp) page on Novu.
* Click the "Add a provider" button.
* Locate **Sendchamp** under the SMS section and click on the **Connect** button.
* Enter your Sendchamp API Key.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Sendchamp** in Novu.


# SimpleTexting
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/simpletexting

Learn how to use the SimpleTexting provider to send sms notifications using Novu

You can use the [SimpleTexting](https://simpletexting.com/) SMS provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use SimpleTexting provider in the SMS channel, the first step is to create a SimpleTexting account and grab your `API KEY` in your settings.

# Creating a SimpleTexting integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-simpletexting) page on Novu.
* Click the "Add a provider" button.
* Locate **SimpleTexting** under the SMS section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `API Key`.
* Enter the `From` value.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **SimpleTexting** in Novu.


# SMS77
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/sms77

Learn how to use the SMS77 provider to send sms notifications using Novu

It is possible to use the [SMS77](https://www.sms77.io/en) provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the SMS77 provider in the SMS channel, the first step is to create an SMS77 account and add the personal API key to the SMS77 integration on the Novu platform.

# Find the API key

To find the SMS77 API key, log into the personal SMS77 account and navigate to the API Keys page by clicking on the 'Developer' tab present at the end of the sidebar. It is suggested to create a new API key for use with Novu. Copy the newly created API key.

# Creating an SMS77 integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-sms77) page on Novu.
* Click the "Add a provider" button.
* Locate **SMS77** under the SMS section and click on the **Connect** button.
* Enter the `API key`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Save** button.
* Now it is possible to send SMS notifications using **SMS77** in Novu.


# Telnyx
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/telnyx

Learn how to use the Telnyx provider to send sms notifications using Novu

You can use the [Telnyx](https://telnyx.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Telnyx provider in the SMS channel, you will need to create a Telnyx account and add your API key to the Telnyx integration on the Novu platform.

# Finding the API Key

To find your Telnyx API key:

* Log into your Telnyx account.
* Navigate to Account Setting.
* Then go to [Keys & Credentials](https://portal.telnyx.com/#/app/api-keys).
* You can copy the API key from there.
* Alternatively, you can create an API key by tapping on the Create API Key button.

Before copying it, make sure its status is showing active.

# Finding the Message Profile ID

To get your Message profile ID:

* Navigate to [Messaging](https://portal.telnyx.com/#/app/messaging) to find the profiles.
* Make sure you created a Telnyx Messaging Profile previously. Learn more [here](https://developers.telnyx.com/docs/v2/messaging/quickstarts/portal-setup).
* Go to the active Messaging Profile.
* Copy the profile ID.

# Making sure that the From address is valid

A valid from address must be a valid phone number in +E.164 format, a short code, or an alphanumeric sender ID associated with the sending messaging profile. Alphanumeric sender IDs must be between 1 and 11 characters long, and can only contain ASCII letters, numbers, and spaces. They must contain at least one letter.

# Creating a Telnyx integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations) page on the Novu.
* Click the "Add a provider" button.
* Locate Telnyx and click on the **Connect** button.
* Enter your Telnyx API Key.
* Fill in the Message profile ID field.
* Enter the Valid From address.
* Click on the `Disabled` button and `mark it as Active`.
* Click on the **Save** button.
* You should now be able to send notifications using Telnyx in Novu.


# Termii
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/termii

Learn how to use the Termii provider to send sms notifications using Novu

You can use the [Termii](https://termii.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Termii provider in the SMS channel, the first step is to create a Termii account and add your API key and Sender ID to the Termii integration on the Novu platform.

## Retrieving your API Key

To find your Termii API key:

* [Sign up](https://accounts.termii.com/#/register) or [Login](https://accounts.termii.com/#/login) to your Termii account.
* Navigate to your [dashboard](https://accounts.termii.com/#/).
* Then scroll to the bottom of the page to find your API key.

<Frame>
  <img />
</Frame>

Alternatively, you can find the API key on the Settings page.

* Scroll to the bottom of the sidebar (on the left) and click on settings.
* This will display a dropdown from which you can then click on `API Token` to view your API key.

<Frame>
  <img />
</Frame>

## Getting your Sender's ID

Sender IDs allow you to brand your messages as you send them to your customers.

To get your Sender's ID:

* On the sidebar (on the menu on your left), click on `Rental`. This will display a dropdown. Click on `SMS Sender IDs` from the dropdown options.
* On the page that appears, you'll find a list of your Sender IDs

<Frame>
  <img />
</Frame>

If you have not created one yet:

* Click on the `Make a new request` button to request a Sender ID.
* Fill in the form
* Click on `Save`

<Frame>
  <img />
</Frame>

## Creating a Termii integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations) page on Novu.
* Click the "Add a provider" button.
* Locate **Termii** under the SMS section and click on the **Connect** button.
* Enter your Termii API Key.
* Fill in the `From` field.
* Click on the Disabled button and mark it as Active.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Termii** in Novu.


# Twilio
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/twilio

Learn how to use the Twilio provider to send sms notifications using Novu

You can utilize the [Twilio](https://www.twilio.com/) API to communicate with your customers using SMS messaging. Let’s look at how you can do that:

# Setting up Twilio

1. First, go to [Twilio](https://www.twilio.com/) and create an account, probably starting with their free trial.
2. You’ll be asked to verify your email and your phone number. Get them verified.
3. Once you’re done with that, you’ll get an option to ‘get a Twilio phone number’ from your Twilio console.
4. Click on it to get your Twilio phone number.

When first using Twilio there should be an option to get a Twilio phone number in the main console. Otherwise, you may have to [Buy](https://console.twilio.com/us1/develop/phone-numbers/manage/search?frameUrl=%2Fconsole%2Fphone-numbers%2Fsearch%3Fx-target-region%3Dus1\&currentFrameUrl=%2Fconsole%2Fphone-numbers%2Fsearch%3FisoCountry%3DUS%26searchTerm%3D%26searchFilter%3Dleft%26searchType%3Dnumber%26x-target-region%3Dus1%26__override_layout__%3Dembed%26bifrost%3Dtrue) a number from that link to begin using it. Assuming this is the first run though, utilize the free number given to us.

Simply follow one of their many [Tutorials](https://www.twilio.com/docs/usage/requests-to-twilio) within their docs to understand every part of the process.

Irrespective of the language you use, the process is the same:

* Load the Account SID and Auth token into the code, using some sort of safe environment such as .env variables. Nobody should have access to this but you.
* Create a client object from Twilio that take the SID and Token as variables then create a message with the client.
* A message is an object that has three things:
  * that free number from earlier,
  * the number you would like to send to, and
  * a body message that you want to send through SMS.

# Creating a Twilio integration with Novu

Creating a Twilio integration with Novu is quite simple. Just follow these steps:

* Visit the [Integrations Store](https://web.novu.co/integrations) on Novu.
* Click the "Add a provider" button.
* Locate **Twilio** and click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.
* Go to your [Console](https://console.twilio.com/) on Twilio and access the Account Info section at the bottom of the page
* Enter your `Account SID`, `Auth Token` and `Twilio Phone Number`.
* Click on the **Save** button.
* You should now be able to send SMS notifications using **Twilio** in Novu.

## Sending an WhatsApp message with Twillio

To send a WhatsApps message with Twillio integration prefix the phone number of the subscriber with `whatsapp:` as shown below.

```ts theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
  {
    to: {
      subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
      phone: 'whatsapp:555-4242'
    },
  }
);
```

Read more about [sending a Message with the Twilio API for WhatsApp](https://www.twilio.com/docs/whatsapp/tutorial).


# Brand
Source: https://v0.x-docs.novu.co/content-creation-design/brand



Through Novu's web dashboard, you have the power to effortlessly tailor your brand settings, streamlining the process of creating notifications. Customize key elements such as your logo, which will be seamlessly integrated into your email communications.

For those utilizing Novu's In-App notification center, the ability to configure the primary font and its corresponding color awaits you. This empowers you to craft an experience for your users that resonates with your unique brand identity.

<img />


# Handlebars & Helpers
Source: https://v0.x-docs.novu.co/content-creation-design/handlebars-helpers



# Handlebars

The Novu notification content editor relies on Handlebars.js to establish the logic and control flow of our workflows.
For a deeper comprehension of Handlebars.js, you can refer to its [documentation](https://handlebarsjs.com/guide/#what-is-handlebars).

This resource offers comprehensive insights into the utilization of Handlebars.js in crafting dynamic and adaptable notification content within the Novu platform.

| Helper          | Description                                                                     | Example                                                          | Output                                                |
| --------------- | ------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ----------------------------------------------------- |
| if              | Conditionally renders a block. Falsy values won't be rendered.                  | `{{#if author}}<h1>{{firstName}} {{lastName}}</h1>{{/if}}`       | Renders `<h1>Yehuda Katz</h1>` if `author` is truthy. |
| includeZero     | `includeZero=true` treats the conditional as not empty, handling 0 differently. | `{{#if 0 includeZero=true}}<h1>Does render</h1>{{/if}}`          | Renders `<h1>Does render</h1>` for 0.                 |
| Sub-Expressions | Create custom logic helpers and use them in sub-expressions.                    | `{{#if (isdefined value1)}}true{{else}}false{{/if}}`             | Renders `true` or `false` based on custom helper.     |
| unless          | Inverse of if helper. Renders a block if the expression is falsy.               | `{{#unless license}}<h3 class="warning">WARNING</h3>{{/unless}}` | Renders warning if `license` is falsy.                |
| each            | Iterate over a list. Use this to reference the iterated element.                | `{{#each people}}<li>{{this}}</li>{{/each}}`                     | Renders list items.                                   |
| with            | Change context for template parts.                                              | `{{#with person}}{{firstname}} {{lastname}}{{/with}}`            | Renders `firstname` and `lastname` from the context.  |
| Nested each     | Access iteration variables in nested each blocks.                               | `{{#each array}}{{@index}}: {{this}}{{/each}}`                   | Renders index and item in each iteration.             |
| Nested with     | Use with block parameters for clear code.                                       | See above example with nested with and complex template.         | Renders nested context values.                        |
|                 | You can use else section to handle empty values.                                | `{{#with city}}...{{else}}No city found{{/with}}`                | Handles empty context case.                           |

# Novu-specific helpers

| Handlebar Expression                       | Description                                                                                                                                                                                                                           |
| ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `{{dateFormat date 'EEEE, MMMM Do yyyy'}}` | You can format the date using the `dateFormat` function. Here, `date: '2020-01-01'` has been formatted into `Wednesday, January 1st 2020`.                                                                                            |
| `{{lowercase key}}`                        | This helps you use the `lowercase` handlebar helper function and turns the value of the specified key to its lowercase value. So, for `message: 'hEllo WORLD'`, if we write `{{lowercase message}}`, we'll end up with `hello world`. |
| `{{uppercase key}}`                        | This helps you use the `uppercase` handlebar helper function and turns the value of the specified key to its uppercase value. So, for `message: 'hello woRld'`, if we write `{{uppercase message}}`, we'll end up with `HELLO WORLD`. |
| `{{titlecase key}}`                        | This helps you use the `titlecase` handlebar helper function and turns the value of the specified key to its titlecase value. So, for `message: 'hEllo wOrLD'`, if we write `{{titlecase message}}`, we'll end up with `Hello World`. |

### groupBy

`groupBy` helper is used to group the items in an array based on a property.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    {{#each (groupBy names "name")}}
      <h1>{{key}}<h1>
      {{#each items}}
        <h3>{{age}}</h3>
      {{/each}}
    {{/each}}
    ```
  </Tab>

  <Tab title="Context">
    ```json theme={null}
    {
      "names": [
        {
          "name": "Name 1",
          "age": "30"
        },
        {
          "name": "Name 2",
          "age": "31"
        },
        {
          "name": "Name 1",
          "age": "32"
        }
      ]
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
    <h1>Name 1<h1>
    <h3>30</h3>
    <h3>32</h3>
    <h1>Name 2<h1>
    <h3>31</h3>
    ```
  </Tab>
</Tabs>

### equals

`equals` helper allows you to perform comparisons, both for boolean expressions and string comparisons.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    <!-- LOGIC -->
    {{#equals value1 value2}}
       <!-- Code to execute when value1 is equal to value2 -->
    {{else}}
       <!-- Code to execute when value1 is not equal to value2 -->
    {{/equals}}


    <!-- Example -->
    {{#equals 10 1}}
       <h2> 10 is equal to 1 </h2>
    {{else}}
       <h1> 10 is not equal to 1 </h1>
    {{/equals}}
    ```
  </Tab>

  <Tab title="Context">
    ```json theme={null}
    {
      "value1" : 10,
      "values2" : 1
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
       <h1> 10 is not equal to 1 </h1>
    ```
  </Tab>
</Tabs>

### numberFormat

`numberFormat` helper is used to format numbers with specified decimal length, thousands separator, and decimal separator.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    <div>{{numberFormat number decimalSep="," decimalLength="2" thousandsSep="|"}}</div>
    <div>{{numberFormat nonNumber decimalSep="," decimalLength="2" thousandsSep="|"}}</div>
    ```
  </Tab>

  <Tab title="Context">
    ```json theme={null}
    {
      "number": 1000000000,
      "nonNumber": "Not a number"
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
    <div>1|000|000|000,00</div>
    <div>Not a number</div>
    ```
  </Tab>
</Tabs>

### pluralize

The `pluralize` helper allows you to easily handle pluralization in your templates by providing different forms of a word depending on a variable value.

### Basic Usage

In its simplest form, the `pluralize` helper takes three arguments:

```
{{pluralize count singular plural}}
```

* `count`: The numeric value that determines whether the singular or plural form should be used.
* `singular`: The singular form of the word.
* `plural`: The plural form of the word.

#### Example

```
{{pluralize dog_count "dog" "dogs"}}
```

In this example, if `dog_count` is equal to 1, it will render "1 dog," and if it's greater than 1, it will render "dogs."

## Use Cases & Examples

### Handling Event Count Display with Excluded Individuals

In some cases, you may want to display the total count of certain events but exclude specific individuals who are already mentioned. For example, when using a phrase like "John and `{{step.total_count}}` people liked your photo," you may notice that the count is off by one because "John" is already mentioned.

To account for such scenarios, you can utilize the following approach:

```
{{#each step.events}}
  {{#if @first}}
    {{this.name}}
  {{else}}
    {{#if @last}}
      and {{@index}}
    {{/if}}
  {{/if}}
{{/each}}
followed you!
```

In this code, we iterate through the `step.events` array and conditionally display each name. If it's the first name in the list, it will be shown without "and." For subsequent names, we add "and" before the last name. This ensures that the count is not affected by names that are explicitly mentioned in the message.

By using this code, you can achieve a more accurate representation of the event count in your messages, even when some users are individually mentioned in the message text.

### Using array length as count

Array length be used as total number of item. For example, if paylod have fruits property of type array then its length can be used as total number of fruits.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    Total number of fruits is {{fruits.length}}.
    ```
  </Tab>

  <Tab title="Payload">
    ```json theme={null}
    {
      "fruits": [
        {
          "name": "Pine apple",
          "price": "10$"
        },
        {
          "name": "Apple",
          "age": "8$"
        },
        {
          "name": "Orange",
          "age": "5$"
        }
      ]
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
    Total number of fruits is 3.
    ```
  </Tab>
</Tabs>

<Note> In a future release, we plan to replace handlebar helpers with an alternative solution. Please note that custom handlebars in the editor itself are not currently supported. If we are missing any handlebar helper that is blocking you to write template for use case, feel free to reach out to us in [discord](https://discord.gg/novu?ref=docs-handlebar-helper)</Note>


# Layouts
Source: https://v0.x-docs.novu.co/content-creation-design/layouts

Explore how to create and manage layouts in Novu

### Email Layouts

Novu allows the creation of layouts - a specific HTML design or structure to wrap content of email notifications. Layouts can be manipulated and assigned to new or existing workflows within the Novu platform, allowing users to create, manage, and assign these layouts to workflows, so they can be reused to structure the appearance of notifications sent through the platform.

By default, Novu will create a default layout and assign it as the organization's default layout. At any time, you can choose any of your layouts as the default for your organization. All new email templates will be assigned the default layout unless assigned a different one through the email editor.

#### Manage Layouts

You can find and manage your organization's layouts in `Brand -> Layouts`

<img />

#### Create and Edit Layouts

You can create new or edit existing layouts through the layout editor.

* You can create any html code to structure your layout.
* Set a layout as default for your organization. Notice there could only be one default layout at a time.
* Manage layout variables - set default values or required variables.

<img />

<Info> Layout content must include `{{{body}}}`, to indicate where the email editor content will be injected inside the layout. </Info>

#### Assign layout to workflow

To assign, choose a layout through the email editor. You can preview your layout combined with your email content through the `Preview` tab.

<img />

#### Override layout on trigger

To override your assigned layout during a trigger event, use the `layoutIdentifier` property.

The layout specified will be used for all emails in the context of that trigger event.

```ts theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

novu.trigger('workflow-identifier', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    attachments: [
      {
        file: fs.readFileSync(__dirname + '/data/test.jpeg'),
        name: 'test.jpeg',
        mime: 'image/jpg',
      },
    ],
  },
  overrides: {
    layoutIdentifier: 'your-layout-identifier',
  },
});
```

<Note> The override layout on trigger functionality is only available on v0.19.0.</Note>

#### Using SDK

Novu SDK supports all layout functionalities:

#### Create a new layout

A new layout can be created with name, description, content, variables and an `isDefault` flag. Here, content param is html content with custom variables.

```tsx theme={null}
const name: string = "layout-name";
const description: string =
  "The description of the layout that will help other users to understand the goal it was created"; // Optional.
const content: string = "<EMAIL_LAYOUT>";
const variables: ITemplateVariable[] = []; // Optional. Will handle the placeholder variables inserted in the email layout (content).
const isDefault: boolean = true; // Optional. All layouts are created as non default if not stated otherwise.

const { _id: layoutId } = await novu.layouts.create({
  name,
  description,
  content,
  variables,
  isDefault,
});
```

```tsx theme={null}
interface ITemplateVariable {
  type: TemplateVariableTypeEnum;
  name: string;
  required?: boolean;
  defaultValue?: string | boolean;
}

enum TemplateVariableTypeEnum {
  STRING = "String",
  ARRAY = "Array",
  BOOLEAN = "Boolean",
}
```

#### Update existing layout

When updating a layout, all properties are optional and the SDK will only update the ones passed.

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout.

const updatedLayout = await novu.layouts.update(layoutId, {
  name,
  description,
  content,
  variables,
  isDefault,
});
```

#### Set default layout

When executing this, the existing default layout in the environment will be automatically set as non default and the chosen layout will be set as default. This action is non reversible.

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout to be set as default.

await novu.layouts.setDefault(layoutId);
```

#### Delete an existing layout

Layouts can also be deleted. The condition to be able to delete a layout is that it is not a default layout and is not assigned in any existing workflow.

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout to be deleted.

await novu.layouts.delete(layoutId);
```

#### Get a layout

Find a layout by layoutId

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout to be found.

const layout = await novu.layouts.get(layoutId);
```

#### List all layouts

List paginated layouts

```tsx theme={null}
const page: number = 0; // Pagination value of the page for the results. First page will be page = 0.
const pageSize: number = 100; // Optional. Pagination value of the amount of layouts per page to return.
const sortBy: string = "createdAt"; // Optional. Property to order the list of the layouts. So far only `createdAt` is supported.
const orderBy: OrderDirectionEnum = -1; // Optional. Direction of the sorting by the property chosen in `sortBy`. Ascendent order is represented by 1 and descendent order is represented by -1.

const layouts = await novu.layouts.list({
  page,
  pageSize,
  sortBy,
  orderBy,
});
```

## API Reference Links

* [Layout Methods](/api-reference/layouts/layout-creation/)


# Content Creation
Source: https://v0.x-docs.novu.co/content-creation-design/notification-content-creation

Explore how to create notification content

To demonstrate the extensive range of possibilities, we've crafted a subscriber profile enriched with various attributes to highlight the flexibility of our system.

```typescript theme={null}
const subscriber = {
    subscriberId: '6427e97d0136cef86a315c46',
    firstName: 'John',
    lastName: 'Doe',
    email: 'john.doe@gmail.com',
    phone: '+98712345677',
    avatar: 'https://sm.ign.com/ign_nordic/cover/a/avatar-gen/avatar-generations_prsz.jpg',
    locale: 'en-US',
    data: {
        plan: 'basic',
        zipcode: 14925,
        validVehicleLicense: true
    }
};
```

Let's go over examples for each communication channel:

## Email

There are multiple ways to craft your email notification content for maximum impact.

<Note>
  Please remember that you have the option to preview the anticipated output of
  your input using the editor. Simply switch from the editing mode to the
  preview mode to see the results.
</Note>

### Regular Editor

Example: Send a personalized welcome email to a user by leveraging their properties.

**Input:**

```html theme={null}
Hello {{subscriber.firstName}} {{subscriber.lastName}}!

We are excited to welcome you to our {{subscriber.data.plan}} plan.
Look forward to receiving daily updates from us on your phone number: {{subscriber.phone}}.

{{#if subscriber.data.validVehicleLicense}}
Why not consider renting a car to visit us?
{{else}}
We're delighted to offer you a train ticket to come see us.
{{/if}}

Should you require any assistance, don't hesitate to reach out.
Best regards,
Your friends at Novu.
```

<img />

**Output:**

```html theme={null}
Hello John Doe!

We are excited to welcome you to our basic plan.
Look forward to receiving daily updates from us on your phone
number: +98712345677.

Why not consider renting a car to visit us?
Should you require any assistance, don't hesitate to reach out.
Best regards,
Your friends at Novu.
```

<img />

### Custom Code Editor

**Input:**

<Accordion title="Email Template Example">
  ```HTML theme={null}
  <!DOCTYPE html>
  <html>
  <head>
    <meta charset="UTF-8">
    <title>Welcome to Novu!</title>
    <style>
        /* Inline styles for email compatibility */
        body {
            font-family: 'Helvetica Neue', Arial, sans-serif;
            background-color: #f4f4f4;
            margin: 0;
            padding: 0;
        }
        .container {
            max-width: 600px;
            margin: 0 auto;
            padding: 20px;
            background-color: #ffffff;
            border-radius: 10px;
            box-shadow: 0 3px 6px rgba(0, 0, 0, 0.1);
        }
        .header {
            text-align: center;
            margin-bottom: 20px;
        }
        .message {
            font-size: 16px;
            line-height: 1.6;
            color: #333333;
            margin-bottom: 20px;
        }
        .cta-button {
            display: inline-block;
            padding: 10px 20px;
            background-color: #007bff;
            color: #ffffff;
            text-decoration: none;
            border-radius: 5px;
            font-weight: bold;
        }
        .signature {
            margin-top: 20px;
            font-style: italic;
            color: #888888;
        }
    </style>
  </head>
  <body>
    <div class="container">
        <div class="header">
            <h1 style="color: #007bff;">Welcome to Novu!</h1>
        </div>
        <div class="message">
            <p>Hello {{subscriber.firstName}} {{subscriber.lastName}}!</p>
            <p>We are thrilled to have you on board with our {{subscriber.data.plan}} plan.</p>
            <p>Get ready to receive daily updates on your phone: {{subscriber.phone}}.</p>
            <p>{{#if subscriber.data.validVehicleLicense}}
                We would like to offer you renting a car to visit us.
            {{else}}
                We would like to buy you a train ticket to visit us.
            {{/if}}</p>
            <p>If you need any assistance or have questions, feel free to reach out.</p>
            <p><a class="cta-button" href="#">Explore Your Options</a></p>
        </div>
        <div class="signature">
            <p>Best regards,<br>Your friends at Novu</p>
        </div>
    </div>
  </body>
  </html>
  ```
</Accordion>

<img />

**Output:**

<img />

<Info>Email Subject, Sender Name and Preheader field accepts system, payload variables and handlebar helpers</Info>
[Explore how to manage Email layouts.](/content-creation-design/layouts)

## In-App

The In-App notification content editor closely resembles the Email notification editor, although with some discernible differences.

<img />

You can:

* Transform notifications into clickable links, redirecting to your specified URLs
* Enjoy unlimited character freedom
* Utilize all variables to craft dynamic and personalized messages
* Infuse your brand's essence with customizable elements
* Drive engagement with action buttons
* Embed avatar images
* Preview the expected output

## SMS

When crafting your SMS notification, you can tap into all the available variables and even add dynamic ones.

<img />

## Chat

We make it effortless to send notifications to chat providers like Slack, Microsoft Teams, and Discord. Meet your users in the tools they use daily.
You have the ability to utilize all variables to craft dynamic and personalized messages.

<img />

## Push

Push channel has two fields `Push Message Title` and `Push Message Content` where user can write hard coded text content or use system, dynamic variables or handlebar helpers to customize notification content.

<img />


# Translations
Source: https://v0.x-docs.novu.co/content-creation-design/translations

Translate notification content to different languages using i18n.

<Info>The feature is only available for **Novu Cloud** users with **Business** or **Enterprise** plans.</Info>

## Introduction

The Translation Management feature allows you to seamlessly adapt your workflows to different languages and automatically apply them based on your customers' locales. It enhances engagement, personalizes the user experience, and allows you to expand your market reach.

To understand how Translation Management works in Novu we need to review its main pillars:

* Translation Groups
* Translation Files
* Localized Message Content
* Subscribers locale

## Translation Groups

Translation Group allows you to efficiently manage translations for diverse languages with shared business significance. For example, the Branding translation group can hold the content related to your company identity, while the Marketing translation group can exclusively house content related to your marketing campaigns. You aren't obligated to divide your translation content, you can manage it all within a single translation group.

To create the Translation Group navigate to the `Translations` page from the main navigation and click on the “Add group” button.

<img />

Before creating your first Translation Group you'll be prompted to specify the default locale for organization. This locale serves as a fallback option for localized messages in cases where the recipient hasn't defined a specific locale.

<img />

After selecting the default language, you can provide the essential details: the group name, group identifier, and select your target languages.

The group identifier is an important value that you will later use in the editor to localize your messages. This is a similar concept that we use across the app to identify the main parts.

<img />

After the group is created, you will land on the group details page on which you can see the list with the empty translations for the languages you choose.

<img />

## Translations

Translations are JSON files that contain the content of your messages in a specific language. For example, if you created a Marketing translation group with two target languages English and German, then your translation JSON files might look like this:

**English (en.json):**

```json theme={null}
{
  "welcome_message": "Welcome to our Marketing Campaign!",
  "learn_more": "Learn More",
  "special_offer": "Special Offer",
  "contact_us": "Contact Us"
}
```

**German (de.json):**

```json theme={null}
{
  "welcome_message": "Willkommen bei unserer Marketingkampagne!",
  "learn_more": "Mehr erfahren",
  "special_offer": "Sonderangebot",
  "contact_us": "Kontaktieren Sie uns"
}
```

To upload your translations click on the “Upload files” button located at the top of the Translation Group details page.

<img />

Select the translation files and click “Open” button.

<img />

With each uploaded translation file, you must indicate the language it references. Additionally, you can verify the correctness of the uploaded file by previewing its contents.

<img />

Click on “Upload files” button. Congratulations you just uploaded the translation files and created the translation group! 🎉

### Localized Message Content

To localize your message content, you need to use the translation variables in the editor. The variables allow you to reference the values from the translation files. It consists of the `i18n` [handlebar](https://docs.novu.co/content-creation-design/handlebars-helpers) helper and path to the translated value.

Let’s take a look at the example: `{{i18n "marketing.welcome_message"}}`.

* `i18n` is the handlebar helper that tells Novu that you would like to use the Translations
* `"marketing.welcome_message"` is the path that is composed of the Translation Group identifier `marketing` and translation JSON file key `welcome_message`

<img />

<Info>i18n variables can be used in `subject` and `preheader` fields of the email step.</Info>

## Subscribers Locale

The subscribers locale defines in which language the message should be delivered to that recipient. When the locale is not specified it will fallback to the default locale set for the organization. The locale format includes ISO language plus the region, for example `de_DE` language German and region Germany.

To update the locale you can use Novu API or any of our SDKs, more information can be found [here](https://docs.novu.co/subscribers/subscribers).

## Editor Examples

### Variables

It is possible to include variables in your translation strings, they should be wrapped in double curly brackets. Their value could be set as a string or as a variable - either a system variable or a variable sent through the payload.

```json theme={null}
{
  "withVariables": "Welcome {{name}} to {{organization}}"
}
```

In the editor:

```handlebars theme={null}
{{i18n "welcome.withVariables" name=subscriber.firstName organization="Novu"}}
```

### Context

By providing a context you can differ translations. Eg. useful to provide gender specific translations.

For example:

```json theme={null}
{
	"friend": "A friend",
	"friend_male": "A boyfriend",
	"friend_female": "A girlfriend"
}
```

In the editor:

```handlebars theme={null}
{{i18n "welcome.friend" context="male"}}
```

Will result in the message `A boyfriend`. Not adding any context will output `A friend`.

### Plurals

To distinguish between plural translation options.

```json theme={null}
{
	"keyWithCount": "{{count}} item",
	"keyWithCount_plural": "{{count}} items",
}
```

In the editor:

```handlebars theme={null}
{{i18n "welcome.keyWithCount" count=7}}
```

Will result in `7 items`

### Date formats

To control date formats, do as follows:

```json theme={null}
{
  "date": "Current date: {{date, dd/MM/yyyy}}",
  "try_date": "Current date: {{date, MM/dd/yyyy}}",
  "intlDateTime": "On the {{date, HH:yyyy}}"
}
```

In the editor:

<Tip>
  Date can be a string or a variable you send in the payload as `{ date: new Date() }`
</Tip>

```handlebars theme={null}
{{i18n "welcome.date" date="12-06-2023"}}
{{i18n "welcome.try_date" date=date}}
{{i18n "welcome.intlDateTime" date=date}}
```


# Workflow Editor
Source: https://v0.x-docs.novu.co/content-creation-design/variables



Novu's content creation tools allow developers to utilize a wealth of variables when designing notification workflows.

As developers construct workflows using Novu, certain status facets—results of batch functions and other steps in the workflow—are auto-generated and can be utilized to control the content displayed in notification templates.

These variables offer dynamic and automated properties that hold subscriber information, such as first and last name, email, phone, and avatar.

For example, developers can insert a subscriber's first name into a workflow by using `{{ subscriber.firstName }}`.

In addition to the subscriber's details, developers can use data payload variables that encapsulate dynamic data meant to be injected into the content of a workflow.

For instance, in the code example the variables username and resetLink are data payload variables that would be adjusted based on the workflow's purpose.

**The utilization of these variables allows Novu to deliver personalized notifications to the receiver, thus improving user experience and accomplishing better communication outcomes.**

## System Variables

### Subscriber Variables

| Variable       | Type     | Description                                                                   |
| -------------- | -------- | ----------------------------------------------------------------------------- |
| `subscriber`   | `Object` | Represents someone who is intended to receive a notification.                 |
| `firstName`    | `String` | The first name of the subscriber.                                             |
| `lastName`     | `String` | The last name of the subscriber.                                              |
| `email`        | `String` | The subscriber's email address.                                               |
| `phone`        | `String` | The phone number associated with the subscriber.                              |
| `avatar`       | `String` | A URL or reference to the subscriber’s avatar or profile picture.             |
| `locale`       | `String` | The preferred locale or language of the subscriber.                           |
| `subscriberId` | `String` | Unique identifier for the subscriber.                                         |
| `data`         | `Object` | An additional object that can hold custom subscriber data as key-value pairs. |

### Actor Variables

| Variable       | Type     | Description                                                              |
| -------------- | -------- | ------------------------------------------------------------------------ |
| `actor`        | `Object` | A subscriber who initiates actions triggering events.                    |
| `firstName`    | `String` | The first name of the actor.                                             |
| `lastName`     | `String` | The last name of the actor.                                              |
| `email`        | `String` | The actor's email address.                                               |
| `phone`        | `String` | The phone number associated with the actor.                              |
| `avatar`       | `String` | A URL or reference to the actor’s avatar or profile picture.             |
| `locale`       | `String` | The preferred locale or language of the actor.                           |
| `subscriberId` | `String` | Unique identifier for the actor.                                         |
| `data`         | `Object` | An additional object that can hold custom actor data as key-value pairs. |

### Step Variables

| Variable      | Type      | Description                                                                 |
| ------------- | --------- | --------------------------------------------------------------------------- |
| `step`        | `Object`  | A component in the execution of a workflow.                                 |
| `digest`      | `Boolean` | Indicates whether digest mode is active or not.                             |
| `events`      | `Array`   | An aggregated collection of events (that are stored when digest is active). |
| `total_count` | `Number`  | Represents the total number of events in the digest.                        |

### Brand Variables

| Variable   | Type     | Description                                                                 |
| ---------- | -------- | --------------------------------------------------------------------------- |
| `branding` | `Object` | Enables customization of the notification's visual identity.                |
| `logo`     | `String` | Insert the brand logo.                                                      |
| `color`    | `String` | Set the primary color of the notification based on the brand configuration. |

### Tenant Variables

| Variable | Type     | Description                                                               |
| -------- | -------- | ------------------------------------------------------------------------- |
| `tenant` | `Object` | Group of users or an organization.                                        |
| `name`   | `String` | Insert the brand logo.                                                    |
| `data`   | `Object` | An additional object that can hold custom tenant data as key-value pairs. |

## Data Payload Variables

Data payload variables encompass the dynamic data intended to be injected into the content of a workflow. These variables are integral components of the payload object, forming part of the parameters for the trigger function.

Here's a more illustrative example of how data payload variables can be employed:

```jsx theme={null}
curl -L -X POST 'https://api.novu.co/v1/events/trigger' \
-H 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
-H 'Content-Type: application/json' \
--data-raw '{
    "name": "password-reset",
    "to": {
        "subscriberId": "6427e97d0136cef86a315c46",
        "email": "john.doe@acme.com"
    },
    "payload": {
        "username": "Jhontheman1969",
        "resetLink": "http://sample.info/password.reset",
        "securityEmail": "john.doe.backup@acme.com",
    }
}'
```

Within this code snippet, the variables `username` and `resetLink` are representative of data payload variables.

Importantly, it's worth noting that the payload itself can encompass any serializable JSON object.

<Info>Avoid use of system reserved variables as normal variables. For example don't use `email` as variable name because `{{subscriber.email}}` is a system reserved variable</Info>


# Concepts
Source: https://v0.x-docs.novu.co/getting-started/concepts

Learn about the key concepts of Novu

## Notification

A notification conveys information from source to recipient, triggered by a workflow acting as a message blueprint. Notifications can be individual or bundled as [digest](/workflows/digest) for user-friendliness.

## Messages

A message in Novu represents a notification delivered to a recipient on a particular channel. Messages contain information about the request that triggered its delivery, a view of the data sent to the recipient, and a timeline of its lifecycle events. [Learn more about messages](/workflows/messages).

## Workflow

All notifications are sent via a workflow. Each workflow acts as a container for the logic and blueprint that are associated with a type of notification in your system. [Learn more](/workflows/notification-workflows)

## Channel

A channel in Novu represents a configured provider, such as Sendgrid for email, to send notifications to your recipients. A channel is the communication-context domain with the recipients (subscribers).

Most providers within Novu use credentials that you supply to deliver notifications on your behalf. These credentials and other settings are what make a configured channel. [Learn more](/channels-and-providers/introduction)

## Subscriber

A subscriber in Novu represents someone who should receive a message. A subscriber's profile information contains important attributes about the subscriber that will be used in messages (name, email). The subscriber object can contain other key-value pairs that can be used to further personalize your messages. [Learn more about subscribers.](/subscribers/subscribers)

## Topics

Topics are a way to group subscribers together so that they can be notified of events at once. A topic is identified by a custom key. This can be helpful for things like sending out marketing emails or notifying users of new features. Topics can also be used to send notifications to the subscribers who have been grouped together based on their interests, location, activities and much more. [Learn more about topics.](/subscribers/topics)

## Activity Feed

Novu provides a notification activity feed that monitors every outgoing message associated with its relevant metadata. This can be used to monitor activity and discover potential issues with a specific provider or a channel type. [Learn more about the activity feed.](/activity-feed/introduction)

## Integration Store

With the help of the integration store, you can easily integrate your favorite delivery provider. During the runtime of the API, the Integrations Store is responsible for storing the configurations of all the providers. [Learn more](/channels-and-providers/integration-store)

## Providers

Providers are the channel service providers (Twilio, Sendgrid, APN, etc,) you connect to Novu so that it can send your notifications. Rather than replacing your existing providers, Novu passes your notifications to the providers you already use via these channel integrations. [Learn more about providers.](/channels-and-providers/introduction)

## Environment

* Production
* Development

Novu uses the concept of environments to ensure logical separation of your data and configuration. This means that subscribers, and preferences created in one environment are **never** accessible to another. [Learn more about environments.](/platform/environments)

## Handlebars & Helpers

Handlebars is a simple templating language that generates HTML.

Novu-specific Helpers make it possible to define custom iterators and other functionality that can invoke the passed block with a new context. [Learn more about helpers.](/content-creation-design/handlebars-helpers)

## Organization

An organization serves as a separate entity within your Novu account. Each organization you create has its own separate integration store, workflows, subscribers, and API keys. This separation of resources allows you to manage multi-tenant environments and separate domains within a single account.

Switching your organization in the UI only affects the UI and does not deactivate any organizations on the API side. Moreover, the message delivery for each organization operates simultaneously.

Keep in mind that workflows and integration stores for one organization cannot be used for subscribers of other organizations.

<img />

To create a new organization, you interact with a drop down menu in the bottom of the left navigation bar within Novu’s application. Type the name of your new organization, and if the name is new, you will see a button that enables you to add a new one.

<img />

To switch between organizations, you again interact with the same drop down menu and switch between the organizations you have in your Novu account.

<img />

## Notification Center

Notification Center is a beautifully designed and highly functional in-app experience for your users that you can add to your product quickly and effortlessly.

The core components of our Notification Center are:

* A list of notifications with real-time updates
* Notification preference management
* State management and actions for notifications (mark as read/unread, and delete)
* And more

[Learn more](/notification-center/introduction)

## Preference

A preference indicates a user's willingness to receive a particular type of notification. Preferences always belong to a user and can be paired with an identifier that represents the account or tenant that the user belongs to (for multi-tenant applications). [Learn more](/subscribers/preferences)

## Delay Actions

The delay action awaits a specified amount of time before moving on to trigger the following steps of the workflow. [Learn more](/workflows/delay-action)

## Digest

The digest engine collects multiple trigger events, aggregates them into a single message and delivers it to the subscriber. [Learn more](/workflows/digest)

## Layouts

Novu allows the creation of layouts - a specific HTML design or structure to wrap content of email notifications. Layouts can be manipulated and assigned to new or existing workflows within the Novu platform, allowing users to create, manage, and assign these layouts to workflows, so they can be reused to structure the appearance of notifications sent through the platform. [Learn more](/content-creation-design/layouts)

## Tenants

A tenant represents a group of users. As a developer, when your apps have organizations, they are referred to as tenants. Tenants in Novu provides the ability to tailor specific notification experiences to users of different **groups** or **organizations**. [Learn more about Novu Tenants.](/tenants/introduction)


# How Does Novu Work?
Source: https://v0.x-docs.novu.co/getting-started/how-novu-works



Novu comprises two fundamental components: an API for data exchange and a dashboard for designing notifications and their accompanying logical rules.

This section provides a broad overview of Novu's functionality, delving into key concepts for your initial Novu journey. If you prefer to dive into development, explore our **[Quick Start guides](/quickstarts/overview)**.

## Architecture

Novu's Object Communication Layer (OCL) is a structured framework that separates communication tasks into specialized components.
Similar to microservices, these components handle specific roles like message passing and data management. By doing so, OCL enhances system maintenance and scalability, making it easier to integrate new functionalities.

Novu's approach goes beyond this, optimizing communication protocols for seamless collaboration and adaptability. It's like providing a playbook for coordinating a dynamic game, ensuring all players are synchronized for any challenge.

<img />


# What is Novu?
Source: https://v0.x-docs.novu.co/getting-started/introduction

Novu is a full-stack (UI, API & GitOps) open source notification infrastructure tool and platform for building, managing, delivering, and monitoring all types of end-user notifications.

Novu supports a variety of common notification channels out-of-the-box, including **email**, **SMS**, **push**, **in-app**, and **chat**. Our platform is a developer-first product built for engineers that need to simplify the complexities of notification management, while working closely with product and marketing teams that need to provide, edit, and maintain notification content.

<AccordionGroup>
  <Accordion title="Get started with our quickstarts">
    Get started in minutes

    <CardGroup>
      <Card title="React" icon="react" href="/quickstarts/react">
        Embed a real-time notification center component in your React application.
      </Card>

      <Card title="Vue" icon="vuejs" href="/quickstarts/vue">
        Embed a real-time notification center component in your Vue application.
      </Card>

      <Card title="Angular" icon="angular" href="/quickstarts/angular">
        Embed a real-time notification center component in your Angular application.
      </Card>

      <Card
        title="Kotlin"
        icon={
<svg
    xmlns="http://www.w3.org/2000/svg"
    width="20"
    height="20"
    viewBox="0 0 256 256"
  >
    <defs>
      <linearGradient
        id="logosKotlinIcon0"
        x1="99.991%"
        x2=".01%"
        y1="-.011%"
        y2="100.01%"
      >
        <stop offset=".344%" stopColor="#E44857" />
        <stop offset="46.89%" stopColor="#C711E1" />
        <stop offset="100%" stopColor="#7F52FF" />
      </linearGradient>
    </defs>
    <path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosKotlinIcon0)" d="M256 256H0V0h256L128 127.949z" />
  </svg>}
        href="/quickstarts/kotlin"
      >
        Embed a real-time notification center component in your Kotlin application.
      </Card>

      <Card
        title="PHP"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#deviconPhp0)" d="M0 64c0 18.593 28.654 33.667 64 33.667c35.346 0 64-15.074 64-33.667c0-18.593-28.655-33.667-64-33.667C28.654 30.333 0 45.407 0 64Z"/><path fill="#777bb3" d="M64 95.167c33.965 0 61.5-13.955 61.5-31.167c0-17.214-27.535-31.167-61.5-31.167S2.5 46.786 2.5 64c0 17.212 27.535 31.167 61.5 31.167Z"/><path d="M34.772 67.864c2.793 0 4.877-.515 6.196-1.53c1.306-1.006 2.207-2.747 2.68-5.175c.44-2.27.272-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.464l-2.473 12.732zM20.173 83.547a.694.694 0 0 1-.68-.828l6.557-33.738a.695.695 0 0 1 .68-.561h14.134c4.442 0 7.748 1.206 9.827 3.585c2.088 2.39 2.734 5.734 1.917 9.935c-.333 1.711-.905 3.3-1.7 4.724a15.818 15.818 0 0 1-3.128 3.92c-1.531 1.432-3.264 2.472-5.147 3.083c-1.852.604-4.232.91-7.07.91h-5.724l-1.634 8.408a.695.695 0 0 1-.682.562z"/><path fill="#fff" d="M34.19 55.826h3.891c3.107 0 4.186.682 4.553 1.089c.607.674.723 2.097.331 4.112c-.439 2.257-1.253 3.858-2.42 4.756c-1.194.92-3.138 1.386-5.773 1.386h-2.786l2.205-11.342zm6.674-8.1H26.731a1.39 1.39 0 0 0-1.364 1.123L18.81 82.588a1.39 1.39 0 0 0 1.363 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.151c2.912 0 5.364-.318 7.287-.944c1.977-.642 3.796-1.731 5.406-3.237a16.522 16.522 0 0 0 3.259-4.087c.831-1.487 1.429-3.147 1.775-4.931c.86-4.423.161-7.964-2.076-10.524c-2.216-2.537-5.698-3.823-10.349-3.823zM30.301 68.557h4.471c2.963 0 5.17-.557 6.62-1.675c1.451-1.116 2.428-2.98 2.938-5.591c.485-2.508.264-4.277-.665-5.308c-.931-1.03-2.791-1.546-5.584-1.546h-5.036l-2.743 14.12m10.563-19.445c4.252 0 7.353 1.117 9.303 3.348c1.95 2.232 2.536 5.347 1.76 9.346c-.322 1.648-.863 3.154-1.625 4.518c-.764 1.366-1.76 2.614-2.991 3.747c-1.468 1.373-3.097 2.352-4.892 2.935c-1.794.584-4.08.875-6.857.875h-6.296l-1.743 8.97h-7.35l6.558-33.739h14.133"/><path d="M69.459 74.577a.694.694 0 0 1-.682-.827l2.9-14.928c.277-1.42.209-2.438-.19-2.87c-.245-.263-.979-.704-3.15-.704h-5.256l-3.646 18.768a.695.695 0 0 1-.683.56h-7.29a.695.695 0 0 1-.683-.826l6.558-33.739a.695.695 0 0 1 .682-.561h7.29a.695.695 0 0 1 .683.826L64.41 48.42h5.653c4.307 0 7.227.758 8.928 2.321c1.733 1.593 2.275 4.14 1.608 7.573l-3.051 15.702a.695.695 0 0 1-.682.56h-7.407z"/><path fill="#fff" d="M65.31 38.755h-7.291a1.39 1.39 0 0 0-1.364 1.124l-6.557 33.738a1.39 1.39 0 0 0 1.363 1.654h7.291a1.39 1.39 0 0 0 1.364-1.124l3.537-18.205h4.682c2.168 0 2.624.463 2.641.484c.132.14.305.795.019 2.264l-2.9 14.927a1.39 1.39 0 0 0 1.364 1.654h7.408a1.39 1.39 0 0 0 1.363-1.124l3.051-15.7c.715-3.686.103-6.45-1.82-8.217c-1.836-1.686-4.91-2.505-9.398-2.505h-4.81l1.421-7.315a1.39 1.39 0 0 0-1.364-1.655zm0 1.39l-1.743 8.968h6.496c4.087 0 6.907.714 8.457 2.14c1.553 1.426 2.017 3.735 1.398 6.93l-3.052 15.699h-7.407l2.901-14.928c.33-1.698.208-2.856-.365-3.474c-.573-.617-1.793-.926-3.658-.926h-5.829l-3.756 19.327H51.46l6.558-33.739h7.292z"/><path d="M92.136 67.864c2.793 0 4.878-.515 6.198-1.53c1.304-1.006 2.206-2.747 2.679-5.175c.44-2.27.273-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.463l-2.475 12.732zM77.54 83.547a.694.694 0 0 1-.682-.828l6.557-33.738a.695.695 0 0 1 .682-.561H98.23c4.442 0 7.748 1.206 9.826 3.585c2.089 2.39 2.734 5.734 1.917 9.935a15.878 15.878 0 0 1-1.699 4.724a15.838 15.838 0 0 1-3.128 3.92c-1.53 1.432-3.265 2.472-5.147 3.083c-1.852.604-4.232.91-7.071.91h-5.723l-1.633 8.408a.695.695 0 0 1-.683.562z"/><path fill="#fff" d="M91.555 55.826h3.891c3.107 0 4.186.682 4.552 1.089c.61.674.724 2.097.333 4.112c-.44 2.257-1.254 3.858-2.421 4.756c-1.195.92-3.139 1.386-5.773 1.386h-2.786l2.204-11.342zm6.674-8.1H84.096a1.39 1.39 0 0 0-1.363 1.123l-6.558 33.739a1.39 1.39 0 0 0 1.364 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.15c2.911 0 5.364-.318 7.286-.944c1.978-.642 3.797-1.731 5.408-3.238a16.52 16.52 0 0 0 3.258-4.086c.832-1.487 1.428-3.147 1.775-4.931c.86-4.423.162-7.964-2.076-10.524c-2.216-2.537-5.697-3.823-10.35-3.823zM87.666 68.557h4.47c2.964 0 5.17-.557 6.622-1.675c1.45-1.116 2.428-2.98 2.936-5.591c.487-2.508.266-4.277-.665-5.308c-.93-1.03-2.791-1.546-5.583-1.546h-5.035Zm10.563-19.445c4.251 0 7.354 1.117 9.303 3.348c1.95 2.232 2.537 5.347 1.759 9.346c-.32 1.648-.862 3.154-1.624 4.518c-.763 1.366-1.76 2.614-2.992 3.747c-1.467 1.373-3.097 2.352-4.892 2.935c-1.793.584-4.078.875-6.856.875h-6.295l-1.745 8.97h-7.35l6.558-33.739h14.133"/><defs><radialGradient id="deviconPhp0" cx="0" cy="0" r="1" gradientTransform="translate(38.426 42.169) scale(84.04136)" gradientUnits="userSpaceOnUse"><stop stopColor="#AEB2D5"/><stop offset=".3" stopColor="#AEB2D5"/><stop offset=".75" stopColor="#484C89"/><stop offset="1" stopColor="#484C89"/></radialGradient></defs></svg>
}
        href="/quickstarts/php"
      >
        Embed a real-time notification center component in your PHP application.
      </Card>

      <Card
        title="Ruby"
        icon={<svg xmlns="http://www.w3.org/2000/svg" width="20" height="19.93" viewBox="0 0 256 255"><defs><linearGradient id="logosRuby0" x1="84.75%" x2="58.254%" y1="111.399%" y2="64.584%"><stop offset="0%" stopColor="#FB7655"/><stop offset="0%" stopColor="#FB7655"/><stop offset="41%" stopColor="#E42B1E"/><stop offset="99%" stopColor="#900"/><stop offset="100%" stopColor="#900"/></linearGradient><linearGradient id="logosRuby1" x1="116.651%" x2="1.746%" y1="60.89%" y2="19.288%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby2" x1="75.774%" x2="38.978%" y1="219.327%" y2="7.829%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby3" x1="50.012%" x2="66.483%" y1="7.234%" y2="79.135%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E57252"/><stop offset="46%" stopColor="#DE3B20"/><stop offset="99%" stopColor="#A60003"/><stop offset="100%" stopColor="#A60003"/></linearGradient><linearGradient id="logosRuby4" x1="46.174%" x2="49.932%" y1="16.348%" y2="83.047%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E4714E"/><stop offset="56%" stopColor="#BE1A0D"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby5" x1="36.965%" x2="49.528%" y1="15.594%" y2="92.478%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="18%" stopColor="#E46342"/><stop offset="40%" stopColor="#C82410"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby6" x1="13.609%" x2="85.764%" y1="58.346%" y2="-46.717%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="54%" stopColor="#C81F11"/><stop offset="99%" stopColor="#BF0905"/><stop offset="100%" stopColor="#BF0905"/></linearGradient><linearGradient id="logosRuby7" x1="27.624%" x2="50.745%" y1="21.135%" y2="79.056%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="31%" stopColor="#DE4024"/><stop offset="99%" stopColor="#BF190B"/><stop offset="100%" stopColor="#BF190B"/></linearGradient><linearGradient id="logosRuby8" x1="-20.667%" x2="104.242%" y1="122.282%" y2="-6.342%"><stop offset="0%" stopColor="#BD0012"/><stop offset="0%" stopColor="#BD0012"/><stop offset="7%" stopColor="#FFF"/><stop offset="17%" stopColor="#FFF"/><stop offset="27%" stopColor="#C82F1C"/><stop offset="33%" stopColor="#820C01"/><stop offset="46%" stopColor="#A31601"/><stop offset="72%" stopColor="#B31301"/><stop offset="99%" stopColor="#E82609"/><stop offset="100%" stopColor="#E82609"/></linearGradient><linearGradient id="logosRuby9" x1="58.792%" x2="11.964%" y1="65.205%" y2="50.128%"><stop offset="0%" stopColor="#8C0C01"/><stop offset="0%" stopColor="#8C0C01"/><stop offset="54%" stopColor="#990C00"/><stop offset="99%" stopColor="#A80D0E"/><stop offset="100%" stopColor="#A80D0E"/></linearGradient><linearGradient id="logosRubya" x1="79.319%" x2="23.088%" y1="62.754%" y2="17.888%"><stop offset="0%" stopColor="#7E110B"/><stop offset="0%" stopColor="#7E110B"/><stop offset="99%" stopColor="#9E0C00"/><stop offset="100%" stopColor="#9E0C00"/></linearGradient><linearGradient id="logosRubyb" x1="92.88%" x2="59.841%" y1="74.122%" y2="39.704%"><stop offset="0%" stopColor="#79130D"/><stop offset="0%" stopColor="#79130D"/><stop offset="99%" stopColor="#9E120B"/><stop offset="100%" stopColor="#9E120B"/></linearGradient><linearGradient id="logosRubyc" x1="56.57%" x2="3.105%" y1="101.717%" y2="11.993%"><stop offset="0%" stopColor="#8B2114"/><stop offset="0%" stopColor="#8B2114"/><stop offset="43%" stopColor="#9E100A"/><stop offset="99%" stopColor="#B3100C"/><stop offset="100%" stopColor="#B3100C"/></linearGradient><linearGradient id="logosRubyd" x1="30.87%" x2="92.471%" y1="35.599%" y2="100.694%"><stop offset="0%" stopColor="#B31000"/><stop offset="0%" stopColor="#B31000"/><stop offset="44%" stopColor="#910F08"/><stop offset="99%" stopColor="#791C12"/><stop offset="100%" stopColor="#791C12"/></linearGradient><radialGradient id="logosRubye" cx="32.001%" cy="40.21%" r="69.573%" fx="32.001%" fy="40.21%"><stop offset="0%" stopColor="#A80D00"/><stop offset="0%" stopColor="#A80D00"/><stop offset="99%" stopColor="#7E0E08"/><stop offset="100%" stopColor="#7E0E08"/></radialGradient><radialGradient id="logosRubyf" cx="13.549%" cy="40.86%" r="88.386%" fx="13.549%" fy="40.86%"><stop offset="0%" stopColor="#A30C00"/><stop offset="0%" stopColor="#A30C00"/><stop offset="99%" stopColor="#800E08"/><stop offset="100%" stopColor="#800E08"/></radialGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby0)" d="m197.467 167.764l-145.52 86.41l188.422-12.787L254.88 51.393l-57.414 116.37Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby1)" d="M240.677 241.257L224.482 129.48l-44.113 58.25l60.308 53.528Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby2)" d="m240.896 241.257l-118.646-9.313l-69.674 21.986l188.32-12.673Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby3)" d="m52.744 253.955l29.64-97.1L17.16 170.8l35.583 83.154Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby4)" d="M180.358 188.05L153.085 81.226l-78.047 73.16l105.32 33.666Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby5)" d="m248.693 82.73l-73.777-60.256l-20.544 66.418l94.321-6.162Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby6)" d="M214.191.99L170.8 24.97L143.424.669l70.767.322Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby7)" d="m0 203.372l18.177-33.151l-14.704-39.494L0 203.372Z"/><path fill="#FFF" d="m2.496 129.48l14.794 41.963l64.283-14.422l73.39-68.207l20.712-65.787L143.063 0L87.618 20.75c-17.469 16.248-51.366 48.396-52.588 49c-1.21.618-22.384 40.639-32.534 59.73Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby8)" d="M54.442 54.094c37.86-37.538 86.667-59.716 105.397-40.818c18.72 18.898-1.132 64.823-38.992 102.349c-37.86 37.525-86.062 60.925-104.78 42.027c-18.73-18.885.515-66.032 38.375-103.558Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby9)" d="m52.744 253.916l29.408-97.409l97.665 31.376c-35.312 33.113-74.587 61.106-127.073 66.033Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubya)" d="m155.092 88.622l25.073 99.313c29.498-31.016 55.972-64.36 68.938-105.603l-94.01 6.29Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyb)" d="M248.847 82.833c10.035-30.282 12.35-73.725-34.966-81.791l-38.825 21.445l73.791 60.346Z"/><path fill="#9E1209" d="M0 202.935c1.39 49.979 37.448 50.724 52.808 51.162l-35.48-82.86L0 202.935Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubye)" d="M155.232 88.777c22.667 13.932 68.35 41.912 69.276 42.426c1.44.81 19.695-30.784 23.838-48.64l-93.114 6.214Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyf)" d="m82.113 156.507l39.313 75.848c23.246-12.607 41.45-27.967 58.121-44.42l-97.434-31.428Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyc)" d="m17.174 171.34l-5.57 66.328c10.51 14.357 24.97 15.605 40.136 14.486c-10.973-27.311-32.894-81.92-34.566-80.814Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyd)" d="m174.826 22.654l78.1 10.96c-4.169-17.662-16.969-29.06-38.787-32.623l-39.313 21.663Z"/></svg>

}
        href="/quickstarts/ruby"
      >
        Embed a real-time notification center component in your Ruby application.
      </Card>
    </CardGroup>
  </Accordion>

  <Accordion title="Explore our SDKs">
    You can interface with Novu's API either over REST, or via libraries for certain languages. Below is a list of our official, supported libraries.

    ### Client Side

    The Client side libraries and components helps to add a fully functional notification center to your application.

    <CardGroup>
      <Card title="React" icon="react" href="/sdks/react">
        Embed a real-time notification center component in your React application.
      </Card>

      <Card title="Vue" icon="vuejs" href="/sdks/vue">
        Embed a real-time notification center component in your Vue application.
      </Card>

      <Card title="Angular" icon="angular" href="/sdks/angular">
        Embed a real-time notification center component in your Angular application.
      </Card>

      <Card title="Web Component" icon="square-js" href="/sdks/web-component">
        Embed a real-time notification center component in your JavaScript application.
      </Card>

      <Card title="IFrame Embed" icon="frame" href="/sdks/iframe-embed">
        Embed a real-time notification center inside an iframe using our embedded script.
      </Card>

      <Card title="Headless JavaScript" icon="js" href="/sdks/headless-javascript-service">
        Embed a notification system into any framework or vanilla JavaScript project, without being constrained by our default UI or dependencies.
      </Card>
    </CardGroup>

    ### Server Side

    The Server Side libraries help to trigger notifications and interact with all of Novu’s API seamlessly.

    <CardGroup>
      <Card
        title="Node.js"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="21.47" viewBox="0 0 512 314"><defs><linearGradient id="logosNodejs0" x1="68.188%" x2="27.823%" y1="17.487%" y2="89.755%"><stop offset="0%" stopColor="#41873F"/><stop offset="32.88%" stopColor="#418B3D"/><stop offset="63.52%" stopColor="#419637"/><stop offset="93.19%" stopColor="#3FA92D"/><stop offset="100%" stopColor="#3FAE2A"/></linearGradient><linearGradient id="logosNodejs1" x1="43.277%" x2="159.245%" y1="55.169%" y2="-18.306%"><stop offset="13.76%" stopColor="#41873F"/><stop offset="40.32%" stopColor="#54A044"/><stop offset="71.36%" stopColor="#66B848"/><stop offset="90.81%" stopColor="#6CC04A"/></linearGradient><linearGradient id="logosNodejs2" x1="-4413.77%" x2="5327.93%" y1="13.43%" y2="13.43%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs3" x1="-4.389%" x2="101.499%" y1="49.997%" y2="49.997%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs4" x1="-9713.77%" x2="27.93%" y1="36.21%" y2="36.21%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs5" x1="-103.861%" x2="100.797%" y1="50.275%" y2="50.275%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs6" x1="130.613%" x2="4.393%" y1="-211.069%" y2="201.605%"><stop offset="0%" stopColor="#41873F"/><stop offset="32.88%" stopColor="#418B3D"/><stop offset="63.52%" stopColor="#419637"/><stop offset="93.19%" stopColor="#3FA92D"/><stop offset="100%" stopColor="#3FAE2A"/></linearGradient><path id="logosNodejs7" d="M57.903 1.85a5.957 5.957 0 0 0-5.894 0L3.352 29.933c-1.85 1.04-2.89 3.005-2.89 5.085v56.286c0 2.08 1.156 4.045 2.89 5.085l48.657 28.085a5.957 5.957 0 0 0 5.894 0l48.658-28.085c1.849-1.04 2.89-3.005 2.89-5.085V35.019c0-2.08-1.157-4.045-2.89-5.085L57.903 1.85Z"/></defs><g fill="none"><path fill="#539E43" d="M253.11 313.094c-1.733 0-3.351-.462-4.854-1.271l-15.371-9.13c-2.312-1.272-1.156-1.734-.462-1.965c3.12-1.04 3.698-1.272 6.934-3.12c.347-.232.81-.116 1.156.115l11.789 7.05c.462.231 1.04.231 1.386 0l46.115-26.698c.462-.231.694-.694.694-1.271v-53.28c0-.579-.232-1.04-.694-1.272l-46.115-26.582c-.462-.232-1.04-.232-1.386 0l-46.115 26.582c-.462.231-.694.809-.694 1.271v53.28c0 .463.232 1.04.694 1.272l12.598 7.281c6.819 3.467 11.095-.578 11.095-4.623v-52.587c0-.693.578-1.387 1.387-1.387h5.894c.694 0 1.387.578 1.387 1.387v52.587c0 9.13-4.97 14.447-13.638 14.447c-2.658 0-4.738 0-10.633-2.89l-12.135-6.934c-3.005-1.733-4.854-4.97-4.854-8.437v-53.28c0-3.467 1.849-6.704 4.854-8.437l46.114-26.698c2.89-1.618 6.82-1.618 9.709 0l46.114 26.698c3.005 1.733 4.855 4.97 4.855 8.437v53.28c0 3.467-1.85 6.704-4.855 8.437l-46.114 26.698c-1.503.694-3.236 1.04-4.854 1.04Zm14.216-36.637c-20.225 0-24.386-9.246-24.386-17.105c0-.694.578-1.387 1.387-1.387h6.01c.693 0 1.271.462 1.271 1.156c.925 6.125 3.583 9.13 15.834 9.13c9.708 0 13.87-2.196 13.87-7.397c0-3.005-1.157-5.2-16.297-6.703c-12.598-1.272-20.457-4.045-20.457-14.1c0-9.362 7.86-14.91 21.035-14.91c14.793 0 22.075 5.086 23 16.18c0 .348-.116.694-.347 1.041c-.232.231-.578.462-.925.462h-6.01c-.578 0-1.156-.462-1.271-1.04c-1.387-6.356-4.97-8.437-14.447-8.437c-10.633 0-11.905 3.699-11.905 6.472c0 3.352 1.503 4.392 15.834 6.241c14.216 1.85 20.92 4.508 20.92 14.447c-.116 10.171-8.437 15.95-23.116 15.95Z"/><path fill="#333" d="M110.028 104.712c0-2.08-1.156-4.046-3.005-5.086l-49.004-28.2c-.81-.463-1.734-.694-2.658-.81h-.463c-.924 0-1.849.347-2.658.81l-49.004 28.2c-1.85 1.04-3.005 3.005-3.005 5.086l.116 75.817c0 1.04.578 2.08 1.502 2.543c.925.578 2.08.578 2.89 0l29.125-16.643c1.849-1.04 3.005-3.005 3.005-5.085v-35.482c0-2.08 1.155-4.045 3.005-5.085l12.366-7.166c.925-.578 1.965-.81 3.005-.81c1.04 0 2.08.232 2.89.81l12.366 7.166c1.85 1.04 3.005 3.004 3.005 5.085v35.482c0 2.08 1.156 4.045 3.005 5.085l29.125 16.643a2.82 2.82 0 0 0 3.005 0c.925-.463 1.503-1.503 1.503-2.543l-.116-75.817ZM345.571.347c-.924-.463-2.08-.463-2.89 0c-.924.578-1.502 1.502-1.502 2.542v75.125c0 .693-.346 1.386-1.04 1.849c-.693.346-1.387.346-2.08 0l-12.251-7.05a5.957 5.957 0 0 0-5.895 0l-49.004 28.316c-1.849 1.04-3.005 3.005-3.005 5.085v56.516c0 2.08 1.156 4.046 3.005 5.086l49.004 28.316a5.957 5.957 0 0 0 5.895 0l49.004-28.316c1.849-1.04 3.005-3.005 3.005-5.086V21.844c0-2.196-1.156-4.16-3.005-5.201L345.572.347Zm-4.507 143.776c0 .578-.231 1.04-.694 1.271l-16.758 9.708a1.714 1.714 0 0 1-1.503 0l-16.758-9.708c-.463-.231-.694-.809-.694-1.271v-19.417c0-.578.231-1.04.694-1.271l16.758-9.709a1.714 1.714 0 0 1 1.503 0l16.758 9.709c.463.23.694.809.694 1.271v19.417Zm167.584-19.879c1.85-1.04 2.89-3.005 2.89-5.086v-13.753c0-2.08-1.156-4.045-2.89-5.085l-48.657-28.2a5.957 5.957 0 0 0-5.895 0l-49.004 28.315c-1.85 1.04-3.005 3.005-3.005 5.085v56.517c0 2.08 1.156 4.045 3.005 5.085l48.657 27.738c1.85 1.04 4.046 1.04 5.78 0L489 178.45c.925-.463 1.503-1.503 1.503-2.543c0-1.04-.578-2.08-1.503-2.543l-49.235-28.316c-.925-.578-1.503-1.502-1.503-2.542v-17.683c0-1.04.578-2.08 1.503-2.543l15.371-8.784a2.821 2.821 0 0 1 3.005 0l15.372 8.784c.925.578 1.502 1.502 1.502 2.543v13.869c0 1.04.578 2.08 1.503 2.542a2.82 2.82 0 0 0 3.005 0l29.125-16.99Z"/><path fill="#539E43" d="M456.292 121.585a1.05 1.05 0 0 1 1.156 0l9.362 5.432c.346.232.577.578.577 1.04v10.865c0 .462-.23.809-.577 1.04l-9.362 5.432a1.05 1.05 0 0 1-1.156 0l-9.361-5.432c-.347-.231-.578-.578-.578-1.04v-10.864c0-.463.23-.81.578-1.04l9.361-5.433Z"/><g transform="translate(134.068 70.501)"><mask id="logosNodejs8" fill="#fff"><use href="#logosNodejs7"/></mask><use fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs0)" href="#logosNodejs7"/><g mask="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs8)"><path d="M51.893 1.85L3.121 29.933C1.27 30.974 0 32.94 0 35.02v56.286c0 1.387.578 2.658 1.502 3.698L56.285 1.156c-1.387-.231-3.005-.116-4.392.693Zm4.739 123.203c.462-.116.925-.347 1.387-.578l48.773-28.085c1.85-1.04 3.005-3.005 3.005-5.085V35.019c0-1.502-.694-3.005-1.734-4.045l-51.43 94.079Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs1)" d="M106.676 29.934L57.788 1.85a8.025 8.025 0 0 0-1.503-.578L1.502 95.12a6.082 6.082 0 0 0 1.619 1.387l48.888 28.085c1.387.809 3.005 1.04 4.507.577l51.432-94.078c-.347-.462-.81-.81-1.272-1.156Z"/></g><g mask="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs8)"><path d="M109.797 91.305V35.019c0-2.08-1.271-4.045-3.12-5.085L57.786 1.85a5.106 5.106 0 0 0-1.848-.693l53.511 91.42c.231-.347.347-.809.347-1.271ZM3.12 29.934C1.272 30.974 0 32.94 0 35.02v56.286c0 2.08 1.387 4.045 3.12 5.085l48.889 28.085c1.156.693 2.427.925 3.814.693L3.467 29.818l-.346.116Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs2)" fillRule="evenodd" d="m50.391.809l-.693.347h.924l-.231-.347Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs3)" fillRule="evenodd" d="M106.792 105.636c1.387-.809 2.427-2.196 2.89-3.698L56.053 10.402c-1.387-.231-2.89-.116-4.16.693L3.351 39.065l52.355 95.465a8.057 8.057 0 0 0 2.196-.693l48.889-28.2Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs4)" fillRule="evenodd" d="m111.3 104.712l-.347-.578v.809l.346-.231Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs5)" fillRule="evenodd" d="m106.792 105.636l-48.773 28.085a6.973 6.973 0 0 1-2.196.693l.925 1.734l54.089-31.32v-.694l-1.387-2.312c-.231 1.618-1.271 3.005-2.658 3.814Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs6)" fillRule="evenodd" d="m106.792 105.636l-48.773 28.085a6.973 6.973 0 0 1-2.196.693l.925 1.734l54.089-31.32v-.694l-1.387-2.312c-.231 1.618-1.271 3.005-2.658 3.814Z" transform="translate(0 -9.246)"/></g></g></g></svg>
}
        href="/sdks/nodejs"
      >
        Connect your Node app to Novu via the Node.js SDK.
      </Card>

      <Card
        title="Go"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="13.13" viewBox="0 0 512 192"><path fill="#00ACD7" d="m292.533 13.295l1.124.75c13.212 8.725 22.685 20.691 28.917 35.15c1.496 2.243.499 3.49-2.493 4.237l-5.063 1.296c-11.447 2.949-20.53 5.429-31.827 8.378l-6.443 1.678c-2.32.574-2.96.333-5.428-2.477l-.348-.399c-3.519-3.988-6.155-6.652-10.817-9.03l-.899-.443c-15.705-7.727-30.911-5.484-45.12 3.74c-16.952 10.968-25.677 27.172-25.428 47.364c.25 19.942 13.96 36.395 33.654 39.137c16.951 2.244 31.16-3.739 42.378-16.452c2.244-2.743 4.238-5.734 6.73-9.224h-48.11c-5.235 0-6.481-3.24-4.736-7.478l.864-2.035c3.204-7.454 8.173-18.168 11.4-24.294l.704-1.319c.862-1.494 2.612-3.513 5.977-3.513h80.224c3.603-11.415 9.449-22.201 17.246-32.407c18.198-23.931 40.135-36.396 69.8-41.63c25.427-4.488 49.359-1.995 71.046 12.713c19.694 13.461 31.909 31.66 35.15 55.59c4.237 33.654-5.485 61.075-28.668 84.508c-16.453 16.702-36.645 27.172-59.829 31.908c-6.73 1.247-13.461 1.496-19.942 2.244c-22.685-.499-43.376-6.98-60.826-21.937c-12.273-10.61-20.727-23.648-24.928-38.828a104.937 104.937 0 0 1-10.47 16.89c-17.949 23.683-41.381 38.39-71.046 42.38c-24.43 3.24-47.115-1.497-67.058-16.454c-18.447-13.96-28.917-32.407-31.66-55.34c-3.24-27.173 4.737-51.603 21.19-73.041c17.7-23.184 41.132-37.891 69.8-43.126c22.999-4.16 45.037-1.595 64.936 11.464ZM411.12 49.017l-.798.178c-23.183 5.235-38.14 19.942-43.624 43.375c-4.488 19.444 4.985 39.138 22.934 47.115c13.71 5.983 27.421 5.235 40.633-1.496c19.694-10.22 30.413-26.175 31.66-47.613c-.25-3.24-.25-5.734-.749-8.227c-4.436-24.401-26.664-38.324-50.056-33.332ZM116.416 94.564c.997 0 1.496.748 1.496 1.745l-.499 5.983c0 .997-.997 1.745-1.745 1.745l-54.344-.249c-.997 0-1.246-.748-.748-1.496l3.49-6.232c.499-.748 1.496-1.496 2.493-1.496h49.857ZM121.9 71.63c.997 0 1.496.748 1.247 1.496l-1.995 5.983c-.249.997-1.246 1.495-2.243 1.495l-117.912.25c-.997 0-1.246-.499-.748-1.247l5.235-6.73c.499-.748 1.745-1.247 2.742-1.247H121.9Zm12.963-22.934c.997 0 1.246.748.748 1.496l-4.238 6.481c-.499.748-1.745 1.496-2.493 1.496l-90.24-.25c-.998 0-1.247-.498-.749-1.246l5.235-6.73c.499-.748 1.745-1.247 2.742-1.247h88.995Z"/></svg>
}
        href="/sdks/go"
      >
        Connect your Golang app to Novu via the Go SDK.
      </Card>

      <Card
        title="PHP"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#deviconPhp0)" d="M0 64c0 18.593 28.654 33.667 64 33.667c35.346 0 64-15.074 64-33.667c0-18.593-28.655-33.667-64-33.667C28.654 30.333 0 45.407 0 64Z"/><path fill="#777bb3" d="M64 95.167c33.965 0 61.5-13.955 61.5-31.167c0-17.214-27.535-31.167-61.5-31.167S2.5 46.786 2.5 64c0 17.212 27.535 31.167 61.5 31.167Z"/><path d="M34.772 67.864c2.793 0 4.877-.515 6.196-1.53c1.306-1.006 2.207-2.747 2.68-5.175c.44-2.27.272-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.464l-2.473 12.732zM20.173 83.547a.694.694 0 0 1-.68-.828l6.557-33.738a.695.695 0 0 1 .68-.561h14.134c4.442 0 7.748 1.206 9.827 3.585c2.088 2.39 2.734 5.734 1.917 9.935c-.333 1.711-.905 3.3-1.7 4.724a15.818 15.818 0 0 1-3.128 3.92c-1.531 1.432-3.264 2.472-5.147 3.083c-1.852.604-4.232.91-7.07.91h-5.724l-1.634 8.408a.695.695 0 0 1-.682.562z"/><path fill="#fff" d="M34.19 55.826h3.891c3.107 0 4.186.682 4.553 1.089c.607.674.723 2.097.331 4.112c-.439 2.257-1.253 3.858-2.42 4.756c-1.194.92-3.138 1.386-5.773 1.386h-2.786l2.205-11.342zm6.674-8.1H26.731a1.39 1.39 0 0 0-1.364 1.123L18.81 82.588a1.39 1.39 0 0 0 1.363 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.151c2.912 0 5.364-.318 7.287-.944c1.977-.642 3.796-1.731 5.406-3.237a16.522 16.522 0 0 0 3.259-4.087c.831-1.487 1.429-3.147 1.775-4.931c.86-4.423.161-7.964-2.076-10.524c-2.216-2.537-5.698-3.823-10.349-3.823zM30.301 68.557h4.471c2.963 0 5.17-.557 6.62-1.675c1.451-1.116 2.428-2.98 2.938-5.591c.485-2.508.264-4.277-.665-5.308c-.931-1.03-2.791-1.546-5.584-1.546h-5.036l-2.743 14.12m10.563-19.445c4.252 0 7.353 1.117 9.303 3.348c1.95 2.232 2.536 5.347 1.76 9.346c-.322 1.648-.863 3.154-1.625 4.518c-.764 1.366-1.76 2.614-2.991 3.747c-1.468 1.373-3.097 2.352-4.892 2.935c-1.794.584-4.08.875-6.857.875h-6.296l-1.743 8.97h-7.35l6.558-33.739h14.133"/><path d="M69.459 74.577a.694.694 0 0 1-.682-.827l2.9-14.928c.277-1.42.209-2.438-.19-2.87c-.245-.263-.979-.704-3.15-.704h-5.256l-3.646 18.768a.695.695 0 0 1-.683.56h-7.29a.695.695 0 0 1-.683-.826l6.558-33.739a.695.695 0 0 1 .682-.561h7.29a.695.695 0 0 1 .683.826L64.41 48.42h5.653c4.307 0 7.227.758 8.928 2.321c1.733 1.593 2.275 4.14 1.608 7.573l-3.051 15.702a.695.695 0 0 1-.682.56h-7.407z"/><path fill="#fff" d="M65.31 38.755h-7.291a1.39 1.39 0 0 0-1.364 1.124l-6.557 33.738a1.39 1.39 0 0 0 1.363 1.654h7.291a1.39 1.39 0 0 0 1.364-1.124l3.537-18.205h4.682c2.168 0 2.624.463 2.641.484c.132.14.305.795.019 2.264l-2.9 14.927a1.39 1.39 0 0 0 1.364 1.654h7.408a1.39 1.39 0 0 0 1.363-1.124l3.051-15.7c.715-3.686.103-6.45-1.82-8.217c-1.836-1.686-4.91-2.505-9.398-2.505h-4.81l1.421-7.315a1.39 1.39 0 0 0-1.364-1.655zm0 1.39l-1.743 8.968h6.496c4.087 0 6.907.714 8.457 2.14c1.553 1.426 2.017 3.735 1.398 6.93l-3.052 15.699h-7.407l2.901-14.928c.33-1.698.208-2.856-.365-3.474c-.573-.617-1.793-.926-3.658-.926h-5.829l-3.756 19.327H51.46l6.558-33.739h7.292z"/><path d="M92.136 67.864c2.793 0 4.878-.515 6.198-1.53c1.304-1.006 2.206-2.747 2.679-5.175c.44-2.27.273-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.463l-2.475 12.732zM77.54 83.547a.694.694 0 0 1-.682-.828l6.557-33.738a.695.695 0 0 1 .682-.561H98.23c4.442 0 7.748 1.206 9.826 3.585c2.089 2.39 2.734 5.734 1.917 9.935a15.878 15.878 0 0 1-1.699 4.724a15.838 15.838 0 0 1-3.128 3.92c-1.53 1.432-3.265 2.472-5.147 3.083c-1.852.604-4.232.91-7.071.91h-5.723l-1.633 8.408a.695.695 0 0 1-.683.562z"/><path fill="#fff" d="M91.555 55.826h3.891c3.107 0 4.186.682 4.552 1.089c.61.674.724 2.097.333 4.112c-.44 2.257-1.254 3.858-2.421 4.756c-1.195.92-3.139 1.386-5.773 1.386h-2.786l2.204-11.342zm6.674-8.1H84.096a1.39 1.39 0 0 0-1.363 1.123l-6.558 33.739a1.39 1.39 0 0 0 1.364 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.15c2.911 0 5.364-.318 7.286-.944c1.978-.642 3.797-1.731 5.408-3.238a16.52 16.52 0 0 0 3.258-4.086c.832-1.487 1.428-3.147 1.775-4.931c.86-4.423.162-7.964-2.076-10.524c-2.216-2.537-5.697-3.823-10.35-3.823zM87.666 68.557h4.47c2.964 0 5.17-.557 6.622-1.675c1.45-1.116 2.428-2.98 2.936-5.591c.487-2.508.266-4.277-.665-5.308c-.93-1.03-2.791-1.546-5.583-1.546h-5.035Zm10.563-19.445c4.251 0 7.354 1.117 9.303 3.348c1.95 2.232 2.537 5.347 1.759 9.346c-.32 1.648-.862 3.154-1.624 4.518c-.763 1.366-1.76 2.614-2.992 3.747c-1.467 1.373-3.097 2.352-4.892 2.935c-1.793.584-4.078.875-6.856.875h-6.295l-1.745 8.97h-7.35l6.558-33.739h14.133"/><defs><radialGradient id="deviconPhp0" cx="0" cy="0" r="1" gradientTransform="translate(38.426 42.169) scale(84.04136)" gradientUnits="userSpaceOnUse"><stop stopColor="#AEB2D5"/><stop offset=".3" stopColor="#AEB2D5"/><stop offset=".75" stopColor="#484C89"/><stop offset="1" stopColor="#484C89"/></radialGradient></defs></svg>
}
        href="/sdks/php"
      >
        Connect your PHP app to Novu via the PHP SDK.
      </Card>

      <Card title="Laravel" icon="laravel" href="/sdks/laravel">
        Connect your Laravel app to Novu via the Laravel SDK.
      </Card>

      <Card
        title=".NET"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 256 256"><g fill="none"><rect width="256" height="256" fill="#512BD4" rx="60"/><path fill="#fff" d="M24.052 168.943c-2.236 0-4.138-.731-5.703-2.194c-1.566-1.501-2.349-3.283-2.349-5.347c0-2.101.783-3.902 2.349-5.403c1.565-1.5 3.466-2.251 5.703-2.251c2.274 0 4.194.751 5.76 2.251c1.603 1.501 2.404 3.302 2.404 5.403c0 2.064-.801 3.846-2.404 5.347c-1.566 1.463-3.486 2.194-5.76 2.194Zm89.415-1.238H98.929l-38.304-59.318a26.371 26.371 0 0 1-2.404-4.672h-.336c.298 1.726.447 5.422.447 11.087v52.903H45.471V87H60.96l37.018 57.912c1.566 2.402 2.572 4.052 3.02 4.953h.223c-.372-2.139-.559-5.759-.559-10.863V87h12.805v80.705Zm62.631 0h-45.014V87h43.225v11.369h-29.916v22.849h27.568v11.312h-27.568v23.863h31.705v11.312Zm63.973-69.336h-23.038v69.336h-13.309V98.369h-22.982V87h59.329v11.369Z"/></g></svg>
}
        href="/sdks/dotnet"
      >
        Connect your C#/.NET app to Novu via the .NET SDK.
      </Card>

      <Card
        title="Ruby"
        icon={
       <svg xmlns="http://www.w3.org/2000/svg" width="20" height="19.93" viewBox="0 0 256 255"><defs><linearGradient id="logosRuby0" x1="84.75%" x2="58.254%" y1="111.399%" y2="64.584%"><stop offset="0%" stopColor="#FB7655"/><stop offset="0%" stopColor="#FB7655"/><stop offset="41%" stopColor="#E42B1E"/><stop offset="99%" stopColor="#900"/><stop offset="100%" stopColor="#900"/></linearGradient><linearGradient id="logosRuby1" x1="116.651%" x2="1.746%" y1="60.89%" y2="19.288%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby2" x1="75.774%" x2="38.978%" y1="219.327%" y2="7.829%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby3" x1="50.012%" x2="66.483%" y1="7.234%" y2="79.135%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E57252"/><stop offset="46%" stopColor="#DE3B20"/><stop offset="99%" stopColor="#A60003"/><stop offset="100%" stopColor="#A60003"/></linearGradient><linearGradient id="logosRuby4" x1="46.174%" x2="49.932%" y1="16.348%" y2="83.047%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E4714E"/><stop offset="56%" stopColor="#BE1A0D"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby5" x1="36.965%" x2="49.528%" y1="15.594%" y2="92.478%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="18%" stopColor="#E46342"/><stop offset="40%" stopColor="#C82410"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby6" x1="13.609%" x2="85.764%" y1="58.346%" y2="-46.717%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="54%" stopColor="#C81F11"/><stop offset="99%" stopColor="#BF0905"/><stop offset="100%" stopColor="#BF0905"/></linearGradient><linearGradient id="logosRuby7" x1="27.624%" x2="50.745%" y1="21.135%" y2="79.056%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="31%" stopColor="#DE4024"/><stop offset="99%" stopColor="#BF190B"/><stop offset="100%" stopColor="#BF190B"/></linearGradient><linearGradient id="logosRuby8" x1="-20.667%" x2="104.242%" y1="122.282%" y2="-6.342%"><stop offset="0%" stopColor="#BD0012"/><stop offset="0%" stopColor="#BD0012"/><stop offset="7%" stopColor="#FFF"/><stop offset="17%" stopColor="#FFF"/><stop offset="27%" stopColor="#C82F1C"/><stop offset="33%" stopColor="#820C01"/><stop offset="46%" stopColor="#A31601"/><stop offset="72%" stopColor="#B31301"/><stop offset="99%" stopColor="#E82609"/><stop offset="100%" stopColor="#E82609"/></linearGradient><linearGradient id="logosRuby9" x1="58.792%" x2="11.964%" y1="65.205%" y2="50.128%"><stop offset="0%" stopColor="#8C0C01"/><stop offset="0%" stopColor="#8C0C01"/><stop offset="54%" stopColor="#990C00"/><stop offset="99%" stopColor="#A80D0E"/><stop offset="100%" stopColor="#A80D0E"/></linearGradient><linearGradient id="logosRubya" x1="79.319%" x2="23.088%" y1="62.754%" y2="17.888%"><stop offset="0%" stopColor="#7E110B"/><stop offset="0%" stopColor="#7E110B"/><stop offset="99%" stopColor="#9E0C00"/><stop offset="100%" stopColor="#9E0C00"/></linearGradient><linearGradient id="logosRubyb" x1="92.88%" x2="59.841%" y1="74.122%" y2="39.704%"><stop offset="0%" stopColor="#79130D"/><stop offset="0%" stopColor="#79130D"/><stop offset="99%" stopColor="#9E120B"/><stop offset="100%" stopColor="#9E120B"/></linearGradient><linearGradient id="logosRubyc" x1="56.57%" x2="3.105%" y1="101.717%" y2="11.993%"><stop offset="0%" stopColor="#8B2114"/><stop offset="0%" stopColor="#8B2114"/><stop offset="43%" stopColor="#9E100A"/><stop offset="99%" stopColor="#B3100C"/><stop offset="100%" stopColor="#B3100C"/></linearGradient><linearGradient id="logosRubyd" x1="30.87%" x2="92.471%" y1="35.599%" y2="100.694%"><stop offset="0%" stopColor="#B31000"/><stop offset="0%" stopColor="#B31000"/><stop offset="44%" stopColor="#910F08"/><stop offset="99%" stopColor="#791C12"/><stop offset="100%" stopColor="#791C12"/></linearGradient><radialGradient id="logosRubye" cx="32.001%" cy="40.21%" r="69.573%" fx="32.001%" fy="40.21%"><stop offset="0%" stopColor="#A80D00"/><stop offset="0%" stopColor="#A80D00"/><stop offset="99%" stopColor="#7E0E08"/><stop offset="100%" stopColor="#7E0E08"/></radialGradient><radialGradient id="logosRubyf" cx="13.549%" cy="40.86%" r="88.386%" fx="13.549%" fy="40.86%"><stop offset="0%" stopColor="#A30C00"/><stop offset="0%" stopColor="#A30C00"/><stop offset="99%" stopColor="#800E08"/><stop offset="100%" stopColor="#800E08"/></radialGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby0)" d="m197.467 167.764l-145.52 86.41l188.422-12.787L254.88 51.393l-57.414 116.37Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby1)" d="M240.677 241.257L224.482 129.48l-44.113 58.25l60.308 53.528Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby2)" d="m240.896 241.257l-118.646-9.313l-69.674 21.986l188.32-12.673Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby3)" d="m52.744 253.955l29.64-97.1L17.16 170.8l35.583 83.154Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby4)" d="M180.358 188.05L153.085 81.226l-78.047 73.16l105.32 33.666Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby5)" d="m248.693 82.73l-73.777-60.256l-20.544 66.418l94.321-6.162Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby6)" d="M214.191.99L170.8 24.97L143.424.669l70.767.322Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby7)" d="m0 203.372l18.177-33.151l-14.704-39.494L0 203.372Z"/><path fill="#FFF" d="m2.496 129.48l14.794 41.963l64.283-14.422l73.39-68.207l20.712-65.787L143.063 0L87.618 20.75c-17.469 16.248-51.366 48.396-52.588 49c-1.21.618-22.384 40.639-32.534 59.73Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby8)" d="M54.442 54.094c37.86-37.538 86.667-59.716 105.397-40.818c18.72 18.898-1.132 64.823-38.992 102.349c-37.86 37.525-86.062 60.925-104.78 42.027c-18.73-18.885.515-66.032 38.375-103.558Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby9)" d="m52.744 253.916l29.408-97.409l97.665 31.376c-35.312 33.113-74.587 61.106-127.073 66.033Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubya)" d="m155.092 88.622l25.073 99.313c29.498-31.016 55.972-64.36 68.938-105.603l-94.01 6.29Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyb)" d="M248.847 82.833c10.035-30.282 12.35-73.725-34.966-81.791l-38.825 21.445l73.791 60.346Z"/><path fill="#9E1209" d="M0 202.935c1.39 49.979 37.448 50.724 52.808 51.162l-35.48-82.86L0 202.935Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubye)" d="M155.232 88.777c22.667 13.932 68.35 41.912 69.276 42.426c1.44.81 19.695-30.784 23.838-48.64l-93.114 6.214Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyf)" d="m82.113 156.507l39.313 75.848c23.246-12.607 41.45-27.967 58.121-44.42l-97.434-31.428Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyc)" d="m17.174 171.34l-5.57 66.328c10.51 14.357 24.97 15.605 40.136 14.486c-10.973-27.311-32.894-81.92-34.566-80.814Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyd)" d="m174.826 22.654l78.1 10.96c-4.169-17.662-16.969-29.06-38.787-32.623l-39.313 21.663Z"/></svg>

}
        href="/sdks/ruby"
      >
        Connect your Ruby app to Novu via the Ruby SDK.
      </Card>

      <Card
        title="Java"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="#0074BD" d="M47.617 98.12s-4.767 2.774 3.397 3.71c9.892 1.13 14.947.968 25.845-1.092c0 0 2.871 1.795 6.873 3.351c-24.439 10.47-55.308-.607-36.115-5.969zm-2.988-13.665s-5.348 3.959 2.823 4.805c10.567 1.091 18.91 1.18 33.354-1.6c0 0 1.993 2.025 5.132 3.131c-29.542 8.64-62.446.68-41.309-6.336z"/><path fill="#EA2D2E" d="M69.802 61.271c6.025 6.935-1.58 13.17-1.58 13.17s15.289-7.891 8.269-17.777c-6.559-9.215-11.587-13.792 15.635-29.58c0 .001-42.731 10.67-22.324 34.187z"/><path fill="#0074BD" d="M102.123 108.229s3.529 2.91-3.888 5.159c-14.102 4.272-58.706 5.56-71.094.171c-4.451-1.938 3.899-4.625 6.526-5.192c2.739-.593 4.303-.485 4.303-.485c-4.953-3.487-32.013 6.85-13.743 9.815c49.821 8.076 90.817-3.637 77.896-9.468zM49.912 70.294s-22.686 5.389-8.033 7.348c6.188.828 18.518.638 30.011-.326c9.39-.789 18.813-2.474 18.813-2.474s-3.308 1.419-5.704 3.053c-23.042 6.061-67.544 3.238-54.731-2.958c10.832-5.239 19.644-4.643 19.644-4.643zm40.697 22.747c23.421-12.167 12.591-23.86 5.032-22.285c-1.848.385-2.677.72-2.677.72s.688-1.079 2-1.543c14.953-5.255 26.451 15.503-4.823 23.725c0-.002.359-.327.468-.617z"/><path fill="#EA2D2E" d="M76.491 1.587S89.459 14.563 64.188 34.51c-20.266 16.006-4.621 25.13-.007 35.559c-11.831-10.673-20.509-20.07-14.688-28.815C58.041 28.42 81.722 22.195 76.491 1.587z"/><path fill="#0074BD" d="M52.214 126.021c22.476 1.437 57-.8 57.817-11.436c0 0-1.571 4.032-18.577 7.231c-19.186 3.612-42.854 3.191-56.887.874c0 .001 2.875 2.381 17.647 3.331z"/></svg>
}
        href="/sdks/java"
      >
        Connect your Java app to Novu via the Java SDK.
      </Card>

      <Card
        title="Kotlin"
        icon={
  <svg
    xmlns="http://www.w3.org/2000/svg"
    width="20"
    height="20"
    viewBox="0 0 256 256"
  >
    <defs>
      <linearGradient
        id="logosKotlinIcon0"
        x1="99.991%"
        x2=".01%"
        y1="-.011%"
        y2="100.01%"
      >
        <stop offset=".344%" stopColor="#E44857" />
        <stop offset="46.89%" stopColor="#C711E1" />
        <stop offset="100%" stopColor="#7F52FF" />
      </linearGradient>
    </defs>
    <path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosKotlinIcon0)" d="M256 256H0V0h256L128 127.949z" />
  </svg>
}
        href="/sdks/kotlin"
      >
        Connect your Kotlin app to Novu via the Kotlin SDK.
      </Card>

      <Card
        title="Python"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="34.87" viewBox="0 0 256 255"><defs><linearGradient id="logosPython0" x1="12.959%" x2="79.639%" y1="12.039%" y2="78.201%"><stop offset="0%" stopColor="#387EB8"/><stop offset="100%" stopColor="#366994"/></linearGradient><linearGradient id="logosPython1" x1="19.128%" x2="90.742%" y1="20.579%" y2="88.429%"><stop offset="0%" stopColor="#FFE052"/><stop offset="100%" stopColor="#FFC331"/></linearGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosPython0)" d="M126.916.072c-64.832 0-60.784 28.115-60.784 28.115l.072 29.128h61.868v8.745H41.631S.145 61.355.145 126.77c0 65.417 36.21 63.097 36.21 63.097h21.61v-30.356s-1.165-36.21 35.632-36.21h61.362s34.475.557 34.475-33.319V33.97S194.67.072 126.916.072ZM92.802 19.66a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.13Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosPython1)" d="M128.757 254.126c64.832 0 60.784-28.115 60.784-28.115l-.072-29.127H127.6v-8.745h86.441s41.486 4.705 41.486-60.712c0-65.416-36.21-63.096-36.21-63.096h-21.61v30.355s1.165 36.21-35.632 36.21h-61.362s-34.475-.557-34.475 33.32v56.013s-5.235 33.897 62.518 33.897Zm34.114-19.586a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.131a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13Z"/></svg>
}
        href="/sdks/python"
      >
        Connect your Python app to Novu via the Python SDK.
      </Card>
    </CardGroup>
  </Accordion>
</AccordionGroup>

The [Novu Cloud SaaS](https://web.novu.co) platform provides an intuitive internal user interface, embeddable UI end-user components, and a hybrid code-first workflow capability.

Novu eliminates the significant burden of building, hosting, and managing a notifications infrastructure that all modern software businesses need in order to notify and engage staff, end users, and customers.

## Notification types

Novu supports different notification types, including user-generated and machine-generated notifications.

### Machine generated

* Triggered by some automated action—think a container pod scaling event.
* Notify one or more end users (which can be internal users, of course!).
* Often can be voluminous, so digests are helpful.

### Product notifications

* Triggered by end-user interactions and events within your product.
* Notify one or more subscribers.
* Typically transactional, such as order updates, password resets, account verifications, or login/OTP codes.
* Can also be used to provide product updates, such as new features or bug fixes.

### Promotional notifications

* Centered on promoting products, services, or events.
* Can be used to generate leads, increase sales, or drive engagement.

### Key Differences

* Product notifications are triggered by user activity, while promotional notifications are sent at the discretion of the marketer.
* Product notifications are typically more transactional in nature, while promotional notifications are more marketing-oriented.
* Product notifications are often sent to all subscribers, while promotional notifications can be targeted to specific audiences.

## Notification channels

Novu supports all major notification channels, and integrates with multiple delivery providers for each one. Each channel can use the same source notification content, as desired.

* [Email](/channels-and-providers/email/overview)
* [Push](/channels-and-providers/push/overview)
* [SMS](/channels-and-providers/sms/overview)
* [Chat](/channels-and-providers/chat/overview)
* [In-App](/channels-and-providers/in-app/introduction)

## Who is Novu for?

How you use and get started with Novu depends on your role. While it’s implemented initially by engineering and development teams, Novu unifies everyone in an organization that authors, creates, sends, manages and measures results from notifications being sent to end users. Novu empowers engineers to deliver notification platforms for product teams.

### Novu for developers and engineering teams

Novu empowers developers and engineering teams to quickly deliver a fully extensible notifications platform for product teams to create captivating notification experiences.

We provide the following proven stack for developers to simply integrate into their products:

* **[Unified API](/api-reference/overview)  & [SDK clients](/sdks/introduction)** for managing all channels and platforms across multiple programming languages.
* **[Prebuilt, customisable UI components](/notification-center/introduction#ui-libraries)** for in-app user notification feeds and preference experiences.
* **[Integration with multiple delivery providers](/channels-and-providers/introduction)**, allowing you to continue using your preferred vendors with Novu.
* **[Scalable, reliable Novu Cloud SaaS infrastructure](https://web.novu.co)** developed from scratch to meet the demands of high-volume notification delivery and storage (think hundreds of millions of notifications).
* **[Observability](/activity-feed/introduction)** for delving into the lifecycle of notification’s success or failure.  Eliminate guesswork of how, when, and why a user receives a notification.
* **Comprehensive documentation**, implementation guides, recipes and illustrative examples.
* **Compliance and security** for safely managing your data.
* **Open source** based provides trust, generates significant community input, and enables you to deploy and self-host a Novu Project instance into any environment of your choosing.

Notification content can be written in a variety of common content tooling, including [React](/framework/integrations/react-email), [Vue-email](/framework/integrations/vue-email), [MJML](/guides/framework-guides/framework-mjml), and more. Content can also be customized and hydrated using any datasource.

### Novu for product teams

We are well aware of the friction that often exists between engineering and product teams, and have built features that allow product teams to customize notification experiences easily and safely—without risking disrupting or breaking important integrations and logic.

Product teams can craft beautiful notification content and campaigns in any content framework of their choice.

* They can modify and manage notification UIs that engineers have built via Novu workflows.
* They gain valuable insights into user engagement with notifications via logs and analytics.
* They can use their preferred notification content editors.
* They can focus on crafting impactful notification content while engineers

### Novu for end users

When implemented, most end users will not be aware that it’s Novu behind the scenes, other than that they now receive notifications where and when they expect them.

The [Novu Notification Center](/notification-center/introduction) is an embeddable component that when included in your app, enables users to view and set their own notification preferences, including channel, preferred language, and more.

Novu ensures fast delivery and beautiful notification experiences for end users regardless of the channels involved.

With Novu, your app users receive instant notifications via **email**, **in-app alerts**, **SMS**, **push notifications**, and **chat**.

## Use Cases

Novu is heavily customizable, and can tackle nearly any notification requirement, no matter how simple or complex. These are some of the more common use cases:

* **Manage multiple notification providers:** Novu empowers you to manage all your notification delivery providers across email, SMS, push and chat in one place. Developers can add new notification providers across different channels without changing the app codebase.
* **Centralize legacy notification systems:** Reduce notification complexity, unify management and visibility into one platform.
* **Centralized debugging of notifications across multiple channels**: Novu allows you understand and debug notifications sent across different channels in one place.
* **In-app Notification Center:** Novu provides a real-time embedded notification center widget that can simply be dropped into any web application to enable end users to manage their own notification preferences.
* **Notification personalization:** Novu provides a user preferences feature that gives your end users a say in how they want to receive notifications.
* **Notification content management:** Novu provides the ability to integrate any content framework and tool of your choice to manage notification content across teams.
* **Send notifications in users language of choice**: Novu allows you to send notifications in preferred users language. App and notification internalization increases users engagement and retention in your product.
* **Reduce notification alert fatigue**: Novu prevents notification fatigue by providing the ability to batch multiple notifications and send as one to subscribers (end users). Leverage Novu in digesting multiple notification events.


# Sign Up on Novu Cloud
Source: https://v0.x-docs.novu.co/getting-started/novu-sign-up

Sign up to our managed service

## Introduction

Novu’s aim is to simplify sending notifications across platforms. As such, we provide simple components, APIs, SDKs and more to help you manage product communication across channels.

This comprehensive guide will help you kickstart your journey with Novu and get your hands dirty!

Everything you need to get up and running successfully can be found here. Let’s begin!

## Signing up to Novu Cloud

Novu Cloud is our managed service that lets you oversee all aspects of your product communication from a user-friendly web dashboard. With Novu Cloud, you can handle various communication channels, create and manage workflows, switch organizations and monitor your activity, ensuring that you get comprehensive control over your product communication and that your message reaches your customers effectively.

To be able to do this and a lot more, you need to sign up for Novu Cloud:

1. Head to [Novu Cloud](https://web.novu.co/auth/signup?utm_campaign=docs-gs-signup). You’ll see this:

<Frame>
  <img />
</Frame>

2. To sign up, you can either use your email and password or sign up using Github. Choose what you wish to proceed with, read the terms and conditions, check its checkbox and click the sign-up button.

<Frame>
  <img />
</Frame>

3. You’ll then be asked to create an Organization. Organizations help you segregate communication between your different products. You can learn more about organisations here. Simply enter your organization name and click on the ‘create’ button:

<Frame>
  <img />
</Frame>

4. On creating an organization, you’ll be greeted with the get started page:

<Frame>
  <img />
</Frame>

This gives you access to a lot of options:

<Frame>
  <img />
</Frame>

1. Accessing support
2. Managing your account
3. Configuring different channels
4. Navigating to any other sections of the dashboard

From here, you can navigate to any part of the web dashboard. Let’s now see Novu in action!


# Send Your First Notification
Source: https://v0.x-docs.novu.co/getting-started/send-your-first-notification

Learn how to send your first notification via the Novu Cloud dashboard.

Sending the first notification is fairly simple, and can be done from within the web dashboard. To send your first notification, follow these steps:

## Workflow for Email notifications

1. Navigate to the workflow section from the left sidebar:

   <Frame>
     <img />
   </Frame>

2. Click on the `Blank Workflow` button to create an empty workflow:

   <Frame>
     <img />
   </Frame>

3. You are now in the workflow editor. Here you can add steps to your workflow. We’ll just drag the email node from the right sidebar to our workflow as illustrated below:

   <Frame>
     <img />
   </Frame>

4. Now, simply click on the email node, and add the subject and the notification
   text in the email node editor:

   <Frame>
     <img />
   </Frame>

5. Now, update the workflow and save it as shown in the image below:

   <Frame>
     <img />
   </Frame>

6. Now, to execute this workflow, click on the `get snippet` button from the workflow editor:

   <Frame>
     <img />
   </Frame>

7. From the `run a test` tab, you can change the email to which you want the notification. Once you’ve done that, simply click on the `Run Trigger` button on the bottom right:

   <Frame>
     <img />
   </Frame>

8. Now, go to the inbox and you’ll see the email notification there. Don’t forget also to check spam as it may sometimes land in there:

   <Frame>
     <img />
   </Frame>

9. This gif below captures the entire process:

   <Frame>
     <img />
   </Frame>

## Workflow for In-App notifications

Creating workflows for sending in-app notifications is pretty straightforward. Just follow the following steps and you'll be good to go:

1. Head to `workflows` on the [Novu web dashboard](https://web.novu.co/workflows?utm_campaign=docs-gs-sendfirstnotification).

   <Frame>
     <img />
   </Frame>

2. Click on the Blank Workflow button to create a workflow from scratch.

   <Frame>
     <img />
   </Frame>

<Note>
  If you want to avoid creating a workflow from scratch, then instead of
  choosing `Blank Workflow`, select `All Templates` and you'll find a bunch of
  workflow templates that you can customize and use:

  <Frame>
    <img />
  </Frame>

  <br />

  <Frame>
    <img />
  </Frame>
</Note>

3. You'll now end up in the workflow editor. Workflow editor, as the name suggests, is the place from where you can edit workflows. You can select which [channels](/channels-and-providers/introduction#channels) you want to send notifications in, add [digest](/guides/add-digest-to-inapp-notifications) to your in-app notifications and more.

   <Frame>
     <img />
   </Frame>

4. For your use case here, we'll simply add an `in-app` node to our workflow.

   <Note>
     Don't forget to rename your workflow to an appropriate name.

     <Frame>
       <img />
     </Frame>
   </Note>

5. Now, the `in-app` node has a lot of options for you to configure:

   <Frame>
     <img />
   </Frame>

* **Preview**: This shows you a glimpse of what each notification item will look like in the Notification Center UI.
* **Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.

6. In this editor, you need to plug in the variable that your backend is expecting in the payload:

   <Frame>
     <img />
   </Frame>

7. You can even use [handlebars](/content-creation-design/handlebars-helpers) to further customise this.

8. Once you're done configuring it, simply click the `update` button on the top right corner.

   <Frame>
     <img />
   </Frame>

9. Now, simply click on the `Get Snippet` button to get the trigger code snippet.

   <Frame>
     <img />
   </Frame>

10. You'll get the code that you need to plug into your backend to be executed whenever an event fires.

    <Frame>
      <img />
    </Frame>

    <br />

    <Warning>
      Don't forget to use your actual `API_KEY` and `subscriberId`.
    </Warning>

That's it, you've successfully built a workflow for sending in-app notifications!

## Workflow for SMS notifications

SMS workflows are not very different from [email](/getting-started/send-your-first-notification#workflow-for-email-notifications) and [in-app](localhost:3001/getting-started/send-your-first-notification#workflow-for-in-app-notifications) workflows we've created above. Let's take a look at it:

1. Head to `Workflows` on the [Novu web dashboard.](https://web.novu.co/workflows?utm_campaign=docs-gs-sendfirstnotification)

   <Frame>
     <img />
   </Frame>

2. Click on the `Blank Workflow` button to create a workflow from scratch.

   <Frame>
     <img />
   </Frame>

<Note>
  If you want to avoid creating a workflow from scratch, then instead of
  choosing `Blank Workflow`, select `All Templates` and you'll find a bunch of
  workflow templates that you can customize and use:

  <Frame>
    <img />
  </Frame>

  <br />

  <Frame>
    <img />
  </Frame>
</Note>

3. You'll now end up in the workflow editor. Workflow editor, as the name suggests, is the place from where you can edit workflows. You can select which [channels](/channels-and-providers/introduction#channels) you want to send notifications in, add [digest](/guides/add-digest-to-inapp-notifications) to your in-app notifications and more.

   <Frame>
     <img />
   </Frame>

4. Since we're creating a workflow for SMS notifications, we'll drag the `SMS` step to our workflow, as shown in this picture below:

   <Frame>
     <img />
   </Frame>

5. If you hover over the SMS node, you will get a message saying 'Required - SMS content\`. Click on the SMS node and add a message to it. This is what will be sent as a notification in the SMS.

   <Frame>
     <img />
   </Frame>

   <br />

   <Note>
     Instead of having static messages, you can have your notifications be
     dynamic by using `handlebars`. Take a look
     [here](/content-creation-design/handlebars-helpers) for more. If your
     backend is expecting data in the payload, plug that variable here in double
     braces.
   </Note>

6. Once you’re done configuring it, simply click the update button on the top right corner.

   <Frame>
     <img />
   </Frame>

7. Now, simply click on the Get Snippet button to get the trigger code snippet.

   <Frame>
     <img />
   </Frame>

8. You’ll get the code that you need to plug into your backend to be executed whenever an event fires.

   <Frame>
     <img />
   </Frame>

   <Warning>Don’t forget to use your actual API\_KEY and subscriberId.</Warning>
   That’s it, you’ve successfully built a workflow for sending in-app
   notifications!

## Workflow for Chat notifications

Chat workflows are quite similar to [email](/getting-started/send-your-first-notification#workflow-for-email-notifications), [in-app](localhost:3001/getting-started/send-your-first-notification#workflow-for-in-app-notifications), and [SMS workflows](/getting-started/send-your-first-notification#workflow-for-sms-notifications) workflows we've created above. Let's take a look at it in detail:

1. Head to `Workflows` on the [Novu web dashboard.](https://web.novu.co/workflows?utm_campaign=docs-gs-sendfirstnotification)

   <Frame>
     <img />
   </Frame>

2. Click on the `Blank Workflow` button to create a workflow from scratch.

   <Frame>
     <img />
   </Frame>

   <br />

   <Note>
     If you want to avoid creating a workflow from scratch, then instead of
     choosing `Blank Workflow`, select `All Templates` and you'll find a bunch
     of workflow templates that you can customize and use:

     <Frame>
       <img />
     </Frame>

     <br />

     <Frame>
       <img />
     </Frame>
   </Note>

3. You'll now end up in the workflow editor. Workflow editor, as the name suggests, is the place from where you can edit workflows. You can select which [channels](/channels-and-providers/introduction#channels) you want to send notifications in, add [digest](/guides/add-digest-to-inapp-notifications) to your in-app notifications and more.

   <Frame>
     <img />
   </Frame>

4. Just add this `Chat` node to the workflow.

   <Frame>
     <img />
   </Frame>

5. In the `Chat` node, you can enter the notification message. This is what will get sent to the [subscriber](/subscribers/subscribers) as a notification. If you're sending dynamic messages, use the variable that is expected in your payload in double braces here. Using [handlebars](/content-creation-design/handlebars-helpers), you can further extend this functionality.

   <Frame>
     <img />
   </Frame>

6. Once you’re done configuring it, simply click the update button on the top right corner.

   <Frame>
     <img />
   </Frame>

7. Now, simply click on the Get Snippet button to get the trigger code snippet.

   <Frame>
     <img />
   </Frame>

8. You’ll get the code that you need to plug into your backend to be executed whenever an event fires.

   <Frame>
     <img />
   </Frame>

   <Warning>Don’t forget to use your actual API\_KEY and subscriberId.</Warning>
   That’s it, you’ve successfully built a workflow for sending chat notifications!

Don't forget to check out our [guides](/guides/add-digest-to-inapp-notifications) and [demo apps](/demos/introduction) for more information on specific features.


# Backend SDK methods
Source: https://v0.x-docs.novu.co/notification-center/backend/methods



### Fetch subscriber’s In-App notifications feed

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: inAppMessages } = await novu.subscribers.getNotificationsFeed(
    "subscriberId",
    {
      page: 0,
      limit: 10,

      // it is of type string. By default all feeds messages are fetched
      feedIdentifier: "Product Updates",

      // seen and read filter of type boolean
      seen: true,
      read: true,
    }
  );
  ```
</CodeGroup>

### Fetch all Messages Sent To All Subscribers

<CodeGroup>
  ```javascript Node.JS theme={null}
  import { ChannelTypeEnum } from "@novu/node";

  // All fields are optional
  const listMessagesOptions = {
    // pagination options
    page: 0,
    limit: 20,

    /**
     *  Filter options
     */
    // use ChannelTypeEnum.PUSH for push, ChannelTypeEnum.EMAIL for email,
    channel: ChannelTypeEnum.IN_APP, // only In-App type messages will be fetched
    subscriberId: "6444105141ffb0919496dfcb",
    transactionIds: ["644-41051-41ffb0-919496-dfcb"],
  };

  const { data: messagesData } = await novu.messages.list(listMessagesOptions);
  ```
</CodeGroup>

### Delete an In-App notification/message

<CodeGroup>
  ```javascript Node.JS theme={null}
  // messageId is of MongoDB Id type
  await novu.messages.deleteById("messageId");
  ```
</CodeGroup>

### Mark an In-App Message as Read/Seen

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: markMessageAsRead } = await novu.subscribers.markMessageRead(
    "subscriberId",
    "messageId"
  );

  const { data: markMessageAsSeen } = await novu.subscribers.markMessageSeen(
    "subscriberId",
    "messageId"
  );
  ```
</CodeGroup>

### Mark an In-App Message as Read/Unread/Seen/Unseen

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: markMessageAs } = await novu.subscribers.markMessageAs(
    "subscriberId",
    "messageId",
    { seen: true, read: false }
  );
  ```
</CodeGroup>

### Mark all In-App Messages as Read/Unread/Seen/Unseen

<CodeGroup>
  ```javascript Node.JS theme={null}
  import { MarkMessagesAsEnum } from "@novu/node"

  const { data: markAllInAppMessages } = await novu.subscribers.markAllMessagesAs(
     'subscriberId',

     // can be filtered with feed identifiers
     feedIdentifier: ['Marketing', 'Product']

     // MarkMessageAsEnum.READ => It will mark all messages as read
     // MarkMessageAsEnum.SEEN => It will mark all messages as seen
     // MarkMessageAsEnum.UNREAD => It will mark all messages as unread
     // MarkMessageAsEnum.UNSEEN => It will mark all messages as unseen
     markAs: MarkMessageAsEnum.Read
  );
  ```
</CodeGroup>

### Fetch All Feeds

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: feedsData } = await novu.feeds.get();
  ```
</CodeGroup>


# Angular Component
Source: https://v0.x-docs.novu.co/notification-center/client/angular



The `@novu/notification-center-angular` package provides an Angular component wrapper over the Notification Center Web Component that you can use to integrate the notification center into your Angular application.

## Installation

<Tip>Novu supports Angular version 15 and higher.</Tip>

<CodeGroup>
  ```bash pnpm theme={null}
  pnpm i @novu/notification-center-angular
  ```

  ```bash npm theme={null}
  npm i @novu/notification-center-angular
  ```

  ```bash yarn theme={null}
  yarn add @novu/notification-center-angular
  ```
</CodeGroup>

## Example usage

Module:

```tsx theme={null}
import { NotificationCenterModule } from '@novu/notification-center-angular';

@NgModule({
  imports: [..., NotificationCenterModule],
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
})
export class TheModule {}
```

Component:

```tsx theme={null}
import { Component } from "@angular/core";
import { environment } from "../environments/environment";

@Component({
  selector: "my-component",
  templateUrl: "./component.html",
})
export class AppComponent {
  subscriberId = environment.subscriberId;
  applicationIdentifier = environment.applicationIdentifier;

  sessionLoaded = (data: unknown) => {
    console.log("loaded", { data });
  };
}
```

Component HTML template:

```html theme={null}
<notification-center-component
  [subscriberId]="subscriberId"
  [applicationIdentifier]="applicationIdentifier"
  [sessionLoaded]="sessionLoaded"
></notification-center-component>
```

## Props

The `notification-center-component` accepts the same set of props as the [web component](/notification-center/client/web-component).

<Tip>
  You may need to add `"allowSyntheticDefaultImports": true` in tsconfig.json for the web component's React imports to work correctly.
</Tip>

## Example

* [Angular Notification Center Example Repo](https://github.com/novuhq/examples/tree/main/novu-angular-notification-center)
* [Example Source Code 🔗](https://github.com/novuhq/examples/tree/main/novu-angular-notification-center)


# Headless API Reference
Source: https://v0.x-docs.novu.co/notification-center/client/headless/api-reference



This page contains the complete documentation about the Headless Notification Center package. You can find here the list of all the methods that you can use.

## initializeSession

To use the headless service, you'll need to initialize the session first. This sets the token and starts the socket listener service.

```typescript theme={null}
headlessService.initializeSession({
  listener: (result: FetchResult<ISession>) => {
    console.log(result);
  },
  onSuccess: (session: ISession) => {
    console.log(session);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IInitializeSession {
  listener: (result: FetchResult<ISession>) => void;
  onSuccess?: (session: ISession) => void;
  onError?: (error: unknown) => void;
}
```

## fetchOrganization

Fetches the details of the current organization

```typescript theme={null}
headlessService.fetchOrganization({
  listener: (result: FetchResult<IOrganizationEntity>) => {
    console.log(result);
  },
  onSuccess: (organization: IOrganizationEntity) => {
    console.log(organization);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchOrganization {
  listener: (result: FetchResult<IOrganizationEntity>) => void;
  onSuccess?: (session: IOrganizationEntity) => void;
  onError?: (error: unknown) => void;
}
```

## fetchUnseenCount

Fetches the count of unseen messages

```typescript theme={null}
headlessService.fetchUnseenCount({
  listener: (result: FetchResult<{ count: number }>) => {
    console.log(result);
  },
  onSuccess: (data: { count: number }) => {
    console.log(data);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchUnseenCount {
  listener: (result: FetchResult<{ count: number }>) => void;
  onSuccess?: (data: { count: number }) => void;
  onError?: (error: unknown) => void;
}
```

## fetchUnreadCount

Fetches the count of unread messages

```typescript theme={null}
headlessService.fetchUnreadCount({
  listener: (result: FetchResult<{ count: number }>) => {
    console.log(result);
  },
  onSuccess: (data: { count: number }) => {
    console.log(data);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchUnreadCount {
  listener: (result: FetchResult<{ count: number }>) => void;
  onSuccess?: (data: { count: number }) => void;
  onError?: (error: unknown) => void;
}
```

## listenNotificationReceive

Listens to a new notification being added. Can be used to retrieve a new notification in real-time and trigger UI changes.

```typescript theme={null}
headlessService.listenNotificationReceive({
  listener: (message: IMessage) => {
    console.log(JSON.stringify(message));
  },
});
```

### method args interface

```typescript theme={null}
interface IListenNotificationReceive {
  listener: (message: IMessage) => void;
}
```

## listenUnseenCountChange

Listens to the changes of the unseen count. Can be used to get real time count of the unseen messages.

```typescript theme={null}
headlessService.listenUnseenCountChange({
  listener: (unseenCount: number) => {
    console.log(unseenCount);
  },
});
```

### method args interface

```typescript theme={null}
interface IListenUnseenCountChanget {
  listener: (unseenCount: number) => void;
}
```

## listenUnreadCountChange

Listens to the changes of the unread count. Can be used to get real time count of the unread messages.

```typescript theme={null}
headlessService.listenUnreadCountChange({
  listener: (unreadCount: number) => {
    console.log(unreadCount);
  },
});
```

### method args interface

```typescript theme={null}
interface IListenUnreadCountChanget {
  listener: (unreadCount: number) => void;
}
```

## fetchNotifications

Retrieves the list of notifications for the subscriber. Can also be used to get the notifications of a particular tab.

```typescript theme={null}
headlessService.fetchNotifications({
  listener: (result: FetchResult<IPaginatedResponse<IMessage>>) => {
    console.log(result);
  },
  onSuccess: (response: IPaginatedResponse<IMessage>) => {
    console.log(
      response.data,
      response.page,
      response.totalCount,
      response.pageSize
    );
  },
  page: pageNumber,
  query: { 
    feedIdentifier: "feedId", 
    read: false, 
    seen: true, 
    // payload sent while triggering the workflow
    payload: {
      message : "Notification message",
      type: "product",
    } 
  },
  storeId: "storeId",
});
```

### method args interface

```typescript theme={null}
interface IFetchNotifications {
  page?: number;
  storeId?: string;
  query?: IStoreQuery;
  listener: (result: FetchResult<IPaginatedResponse<IMessage>>) => void;
  onSuccess?: (messages: IPaginatedResponse<IMessage>) => void;
  onError?: (error: unknown) => void;
}
```

## fetchUserPreferences

Fetches the user [preferences](/subscribers/preferences)

```typescript theme={null}
headlessService.fetchUserPreferences({
  listener: (result: FetchResult<IUserPreferenceSettings[]>) => {
    console.log(result);
  },
  onSuccess: (settings: IUserPreferenceSettings[]) => {
    console.log(settings);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchUserPreferences {
  listener: (result: FetchResult<IUserPreferenceSettings[]>) => void;
  onSuccess?: (settings: IUserPreferenceSettings[]) => void;
  onError?: (error: unknown) => void;
}
```

## updateUserPreferences

Updates the user [preferences](/subscribers/preferences).

```typescript theme={null}
headlessService.updateUserPreferences({
  listener: (
    result: UpdateResult<
      IUserPreferenceSettings,
      unknown,
      IUpdateUserPreferencesVariables
    >
  ) => {
    console.log(result);
  },
  onSuccess: (settings: IUserPreferenceSettings) => {
    console.log(settings);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  templateId: "templateId",
  channelType: "SMS",
  checked: true,
});
```

### method args interface

```typescript theme={null}
interface IUpdateUserPreferences {
  templateId: IUpdateUserPreferencesVariables["templateId"];
  channelType: IUpdateUserPreferencesVariables["channelType"];
  checked: IUpdateUserPreferencesVariables["checked"];
  listener: (
    result: UpdateResult<
      IUserPreferenceSettings,
      unknown,
      IUpdateUserPreferencesVariables
    >
  ) => void;
  onSuccess?: (settings: IUserPreferenceSettings) => void;
  onError?: (error: unknown) => void;
}
```

## markNotificationsAsRead

Mark a single or multiple notifications as read using the message id.

```typescript theme={null}
headlessService.markNotificationsAsRead({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: ["messageOne", "messageTwo"],
});
```

### method args interface

```typescript theme={null}
interface IMarkNotificationsAsRead {
  messageId: IMessageId;
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## markNotificationsAsSeen

Mark a single or multiple notifications as seen using the message id.

```typescript theme={null}
headlessService.markNotificationsAsSeen({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: ["messageOne", "messageTwo"],
});
```

### method args interface

```
interface IMarkNotificationsAsSeen {
  messageId: IMessageId;
  listener: (result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}

```

## markNotificationsAs

Mark a single or multiple notifications using the message id.

```typescript theme={null}
headlessService.markNotificationsAs({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: ["messageOne", "messageTwo"],
  mark: { seen: true, read: true };
});
```

### method args interface

```typescript theme={null}
interface IMarkNotificationsAs {
  messageId: IMessageId;
  mark: { seen?: boolean; read?: boolean };
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## removeNotification

Removes a single notification using the message id.

```typescript theme={null}
headlessService.removeNotification({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: string }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: "messageOne",
});
```

### method args interface

```typescript theme={null}
interface IRemoveNotification {
  messageId: string;
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: string }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## removeNotifications

<Note>This method is available from version 0.23.1</Note>

Removes multiple notifications using array of message ids (limit of 100).

```typescript theme={null}
headlessService.removeNotifications({
  listener: (
    result: UpdateResult<void, unknown, { messageIds: string[] }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageIds: ["message_id_1", "message_id_2" ],
});
```

### method args interface

```typescript theme={null}
interface IRemoveNotification {
  messageIds: string[];
  listener: (
    result: UpdateResult<void, unknown, { messageIds: string[] }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## removeAllNotifications

Removes all notifications. Can be used to remove all notifications of a feed by passing the `feedId`

```typescript theme={null}
headlessService.removeAllNotifications({
  listener: (result: UpdateResult<void, unknown, undefined>) => {
    console.log(result);
  },
  onSuccess: () => {
    console.log("success");
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  feedId: "feedOne",
});
```

### method args interface

```typescript theme={null}
interface IRemoveAllNotifications {
  feedId?: string;
  listener: (result: UpdateResult<void, unknown, undefined>) => void;
  onSuccess?: () => void;
  onError?: (error: unknown) => void;
}
```

## updateAction

Updates the action button for the notifications.

```typescript theme={null}
headlessService.updateAction({
  listener: (
    result: UpdateResult<IMessage, unknown, IUpdateActionVariables>
  ) => {
    console.log(result);
  },
  onSuccess: (data: IMessage) => {
    console.log(data);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: "messageOne",
  actionButtonType: "primary",
  status: "done",
  payload: {
    abc: "def",
  },
});
```

### method args interface

```typescript theme={null}
interface IUpdateAction {
  messageId: IUpdateActionVariables["messageId"];
  actionButtonType: IUpdateActionVariables["actionButtonType"];
  status: IUpdateActionVariables["status"];
  payload?: IUpdateActionVariables["payload"];
  listener: (
    result: UpdateResult<IMessage, unknown, IUpdateActionVariables>
  ) => void;
  onSuccess?: (data: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## markAllMessagesAsRead

Mark subscriber's all unread messages as read. Can be used to mark all messages as read of a single or multiple feeds by passing the `feedId`

```typescript theme={null}
headlessService.markAllMessagesAsRead({
  listener: (result: UpdateResult<number, unknown, undefined>) => {
    console.log(result);
  },
  onSuccess: (count: number) => {
    console.log(count);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  feedId: ["feedOne", "feedTwo"],
});
```

### method args interface

```typescript theme={null}
interface IMarkAllMessagesAsRead {
  listener: (result: UpdateResult<number, unknown, undefined>) => void;
  onSuccess?: (count: number) => void;
  onError?: (error: unknown) => void;
  feedId?: IFeedId;
}
```

## markAllMessagesAsSeen

Mark subscriber's all unread messages as seen. Can be used to mark all messages as seen of a single or multiple feeds by passing the `feedId`

```typescript theme={null}
headlessService.markAllMessagesAsSeen({
  listener: (result: UpdateResult<number, unknown, undefined>) => {
    console.log(result);
  },
  onSuccess: (count: number) => {
    console.log(count);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  feedId: ["feedOne", "feedTwo"],
});
```

### method args interface

```typescript theme={null}
interface IMarkAllMessagesAsSeen {
  listener: (result: UpdateResult<number, unknown, undefined>) => void;
  onSuccess?: (count: number) => void;
  onError?: (error: unknown) => void;
  feedId?: IFeedId;
}
```

## Types and Interfaces

```typescript theme={null}
interface IHeadlessServiceOptions {
  backendUrl?: string;
  socketUrl?: string;
  applicationIdentifier: string;
  subscriberId?: string;
  subscriberHash?: string;
  config?: {
    retry?: number;
    retryDelay?: number;
  };
}

interface ISession {
  token: string;
  profile: ISubscriberJwt;
}

interface ISubscriberJwt {
  _id: string;
  firstName: string;
  lastName: string;
  email: string;
  subscriberId: string;
  organizationId: string;
  environmentId: string;
  aud: "widget_user";
}

interface IUpdateUserPreferencesVariables {
  templateId: string;
  channelType: string;
  checked: boolean;
}

enum ButtonTypeEnum {
  PRIMARY = "primary",
  SECONDARY = "secondary",
  CLICKED = "clicked",
}

enum MessageActionStatusEnum {
  PENDING = "pending",
  DONE = "done",
}

interface IUpdateActionVariables {
  messageId: string;
  actionButtonType: ButtonTypeEnum;
  status: MessageActionStatusEnum;
  payload?: Record<string, unknown>;
}

type FetchResult<T = unknown> = Pick<
  QueryObserverResult<T>,
  "data" | "error" | "status" | "isLoading" | "isFetching" | "isError"
>;

type UpdateResult<
  TData = unknown,
  TError = unknown,
  TVariables = unknown
> = Pick<
  MutationObserverResult<TData, TError, TVariables>,
  "data" | "error" | "status" | "isLoading" | "isError"
>;

type IMessageId = string | string[];
type IFeedId = string | string[];
```

<Tip>
  QueryObserverResult and MutationObserverResult are imported from
  the `@tanstack/query-core` library.
</Tip>


# Get Started
Source: https://v0.x-docs.novu.co/notification-center/client/headless/get-started



The headless version of Novu's notification library package provides users with a lightweight solution for integrating notification functionality into their web applications. With just the essential API methods, users can easily incorporate our notification system into any framework or vanilla JavaScript project, without being constrained by our default UI or dependencies.

## Installation

```bash theme={null}
npm install @novu/headless
```

Then, in your project import the headless service:

```
import { HeadlessService, FetchResult, ISession } from '@novu/headless';
```

## Initialize the session

To use the headless service and its features, you'll need to first initialize the session:

```tsx theme={null}
const headlessService = new HeadlessService({
  applicationIdentifier: "APPLICATION_IDENTIFIER",
  subscriberId: "SUBSCRIBER_ID",
});

headlessService.initializeSession({
  listener: (res: FetchResult<ISession>) => {
    console.log(res);
  },
  onSuccess: (session: ISession) => {
    console.log(session);
  },
  onError: (error) => {
    console.error(error);
  },
});
```

## Use your own backend and socket url

By default, Novu's hosted services of API and socket are used. Should you want, you could override them and configure your own.

```tsx theme={null}
const headlessService = new HeadlessService({
  applicationIdentifier: "APPLICATION_IDENTIFIER",
  subscriberId: "SUBSCRIBER_ID",
  backendUrl: "YOUR_BACKEND_URL",
  socketUrl: "YOUR_SOCKET_URL",
});

headlessService.initializeSession({
  listener: (session) => {
    console.log(session);
  },
  onSuccess: (session) => {
    console.log(session);
  },
  onError: (error) => {
    console.error(error);
  },
});
```

## Fetch Notifications

```jsx theme={null}
import { IPaginatedResponse, IMessage } from "@novu/headless";

headlessService.fetchNotifications({
  listener: ({ data, error, isError, isFetching, isLoading, status }) => {
    console.log({ data, error, isError, isFetching, isLoading, status });
  },
  onSuccess: (response: IPaginatedResponse<IMessage>) => {
    console.log(
      response.data,
      response.page,
      response.totalCount,
      response.pageSize
    );
  },
  page: 1, // page number to be fetched
});
```

<Note>fetchNotifications and other methods of the headless service should be used after initializing the session using headlessService.initializeSession</Note>

## HMAC Encryption

To use the Hash-Based Message Authentication Codes pass the HMAC code to the headless service:

```typescript theme={null}
const headlessService = new HeadlessService({
  applicationIdentifier: "APP_ID_FROM_ADMIN_PANEL",
  subscriberId: "USER_ID",
  subscriberHash: "HASHED_SUBSCRIBER_ID",
});
```

## Realtime Sockets

Novu headless library provides listenUnseenCountChange API to listen to real-time socket changes and get updates about new notifications added to the user's feed.

### unseen count changes

```typescript theme={null}
headlessService.listenUnseenCountChange({
  // this will run every time there's a change in the `unseen_count` in real-time
  listener: (unseenCount: number) => {
    console.log(unseenCount);
  },
});
```

### unread count changes

```typescript theme={null}
headlessService.listenUnreadCountChange({
  // this will run every time there's a change in the `unread_count` in real-time
  listener: (unreadCount: number) => {
    console.log(unreadCount);
  },
});
```

<Tip>
  If you're ready to start using the Headless Notification Center, check out our [guide!](/guides/headless-notification-center-guide)
</Tip>

[Explore Implementation of the Headless Library in an App](https://github.com/novuhq/novu-headless-demo-app)

[Headless Demo](https://headlessdemo.vercel.app)

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="How to use headless library for multiple users? ">
    We have `headless.initializeSession` method to generate token and initialize the session. If user log out and new user login, then calling again this method with second user subscriberId will generate new token and new session.
  </Accordion>

  <Accordion title="Can headless be used with mobile based platforms like flutter and react native?">
    Currently, headless can not be used with react native and flutter. Checkout the progress on mobile platform support on github issue [#4499](https://github.com/novuhq/novu/issues/4499).
  </Accordion>
</AccordionGroup>


# Iframe Embed
Source: https://v0.x-docs.novu.co/notification-center/client/iframe



If you are using a (currently) unsupported client framework, you can use our embedded script. This will generate the notification center inside an iframe

```html theme={null}
<script>
  (function (n, o, t, i, f) {
    n[i] = {};
    var m = ["init", "on"];
    n[i]._c = [];
    m.forEach(
      (me) =>
        (n[i][me] = function () {
          n[i]._c.push([me, arguments]);
        })
    );
    var elt = o.createElement(f);
    elt.type = "text/javascript";
    elt.async = true;
    elt.src = t;
    var before = o.getElementsByTagName(f)[0];
    before.parentNode.insertBefore(elt, before);
  })(
    window,
    document,
    "https://embed.novu.co/embed.umd.min.js",
    "novu",
    "script"
  );

  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
    },
    {
      subscriberId: "SUBSCRIBER_ID",
      email: "SUBSCRIBER_EMAIL",
      first_name: "SUBSCRIBER_FIRST_NAME",
      last_name: "SUBSCRIBER_LAST_NAME",
    }
  );
</script>
```

Replace the selectors for the bell icon and the unseen badge within your code. Let's take a look at this example code:

```html theme={null}
<nav>
  <div id="notification-bell">
    <i class="fa fa-bell"></i>
    <span id="unseen-badge"></span>
  </div>
</nav>
```

## Customizing the dropdown position

Optionally, the embedded init script receives a position object, you can use this to specify the `left` and `top` position of the notification center.

```html theme={null}
<script>
  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      position: {
        top: "50px",
        left: "100px",
      },
    },
    {
      ...subscriberProps,
    }
  );
</script>
```

## Customizing the theme

The notification center component can be customized by passing a `theme` to the init script. Checkout all possible theme [properties](/notification-center/client/react/api-reference).

```html theme={null}
<script>
  const customTheme = {
    light: {
      layout: {
        background: "red",
      },
    },
  };

  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      theme: customTheme,
    },
    {
      ...subscriberProps,
    }
  );
</script>
```

## Customizing the UI language

The language of the UI can be customized by passing an `i18n` component to the init script. More information on all possible [properties](/notification-center/client/react/customization#customize-the-ui-language).

```html theme={null}
<script>
  const customLanguage = {
    lang: "en",
    translations: {
      notifications: "My custom notifications!",
    },
  };

  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      i18n: customLanguage,
    },
    {
      ...subscriberProps,
    }
  );
</script>
```

## Handle User Interaction

In order to handle certain events like the user clicking on the notification, or clicking on an action button inside a notification, you can listen for these events and handle them accordingly.

```html theme={null}
<script>
  novu.on("notification_click", (notification) => {
    // do custom logic here
  });

  novu.on("action_click", ({ templateIdentifier, type, notification }) => {
    // do custom logic here
  });
</script>
```

## Enabling HMAC Encryption

In order to enable Hash-Based Message Authentication Codes, you need to visit the admin panel's In-App settings page and enable HMAC encryption for your environment.

The next step would be to generate an HMAC encrypted subscriberId on your backend:

```javascript theme={null}
import { createHmac } from "crypto";

const hmacHash = createHmac("sha256", process.env.NOVU_API_KEY)
  .update(subscriberId)
  .digest("hex");
```

Then pass the created HMAC to your client side application forward it to the embed initialization script:

```html theme={null}
<script>
  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      position: {
        top: "50px",
        left: "100px",
      },
    },
    {
      subscriberId: "SUBSCRIBER_ID_PLAIN_VALUE",
      subscriberHash: "SUBSCRIBER_ID_HASH_VALUE",
    }
  );
</script>
```

## Example

[![Edit novu-iframe-nc](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/novu-iframe-nc-t9ns9d?fontsize=14\&hidenavigation=1\&theme=dark)

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="The notification bell is not showing in the iframe.">
    We use font awesome bell icon. Make sure you have added the font awesome CSS cdn link in the head tag.

    ```html theme={null}
    <link
      rel="stylesheet"
      href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css"
      integrity="sha512-iecdLmaskl7CVkqkXNQ/ZH/XLlvWZOJyj7Yy7tcenmpD1ypASozpmT/E0iPtmFIB46ZmdtAc9eNBvH0H/ZpiBw=="
      crossorigin="anonymous"
      referrerpolicy="no-referrer"
    />
    ```
  </Accordion>
</AccordionGroup>


# API Reference
Source: https://v0.x-docs.novu.co/notification-center/client/react/api-reference



## React Notification Center API Reference

This page contains complete documentation about the React Notification Center package. You can find here the list of all the components, hooks, and props that you can use.

## Components

Components are the building blocks of the React Notification Center package. They are used to build the UI of the notification center.

## NovuProvider

The NovuProvider is the root component of the React Notification Center package. It is used to wrap the components code and provide the notifications feed context to all its children.
It's responsible for establishing the notification center session, managing the web socket connection, and fetching the notifications feed.

| Prop                    | Type                                                                           | Description                                                                                                                                                                                                                                                                                                                                                                     |
| ----------------------- | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| backendUrl              | string (optional)                                                              | The custom backend URL, your own deployed instance of the API. The default is [https://api.novu.co.app/](https://api.novu.co.app/).                                                                                                                                                                                                                                             |
| socketUrl               | string (optional)                                                              | The custom socket URL, your own deployed instance of the WS app. The default is [https://ws.novu.co/](https://ws.novu.co/).                                                                                                                                                                                                                                                     |
| applicationIdentifier   | string                                                                         | The app id is taken from the Novu Settings -> API Keys tab.                                                                                                                                                                                                                                                                                                                     |
| subscriberId            | string                                                                         | The unique user id from your system.                                                                                                                                                                                                                                                                                                                                            |
| subscriberHash          | string (optional)                                                              | The HMAC encrypted subscriberId. Read about [hmac encryption](/notification-center/client/react/get-started#hmac-encryption)                                                                                                                                                                                                                                                    |
| stores                  | [IStore](#store-interface) (optional)                                          | The connection object between feed and notification center tab.                                                                                                                                                                                                                                                                                                                 |
| i18n                    | [ITranslationEntry \| ITranslationContent](#i18nlanguage-interface) (optional) | The prop allows to configure the UI language.                                                                                                                                                                                                                                                                                                                                   |
| styles                  | [NotificationCenterStyles](#styles-interface) (optional)                       | The prop allowing to style the notification center. It's based on the CSSInterpolation object from the [@emotion/css](https://emotion.sh/docs/@emotion/css#object-styles) package.                                                                                                                                                                                              |
| initialFetchingStrategy | [IFetchingStrategy](#fetching-strategy-interface) (optional)                   | The fetching strategy. By default notifications feed and user preferences are not fetched until the notification center is opened. You might need to tweak this configuration when building a custom UI and if you need to fetch notifications right away. Also it's possible to change it when some action happens using the useNovuContext hook and setFetchingStrategy prop. |
| children                | object                                                                         | The ReactNode object type, the "consumer" of the NovuProvider context.                                                                                                                                                                                                                                                                                                          |
| onLoad                  | [function](#props-interface) (optional)                                        | The function that is called with an organization object after the notification center session is initialized.                                                                                                                                                                                                                                                                   |

### Props interface

```typescript theme={null}
interface INovuProviderProps {
  backendUrl?: string;
  socketUrl?: string;
  applicationIdentifier: string;
  subscriberId?: string;
  subscriberHash?: string;
  stores?: IStore[];
  i18n?: I18NLanguage | ITranslationEntry;
  styles?: INotificationCenterStyles;
  initialFetchingStrategy?: Partial<IFetchingStrategy>;
  children: React.ReactNode;
  onLoad?: (data: { organization: IOrganizationEntity }) => void;
}
```

### Store interface

```typescript theme={null}
interface IStore {
  storeId: string;
  query?: IStoreQuery;
}

interface IStoreQuery {
  feedIdentifier?: string | string[];
  seen?: boolean;
  read?: boolean;
  limit?: number; 
  payload?: Record<string, unknown>;
}
```

### I18NLanguage interface

```typescript theme={null}
type I18NLanguage = 'en' | 'de' ...;

interface ITranslationContent {
  readonly notifications: string;
  readonly markAllAsRead: string;
  readonly poweredBy: string;
  readonly settings: string;
  readonly removeMessage: string;
  readonly markAsRead: string;
  readonly markAsUnRead: string;
}

interface ITranslationEntry {
  readonly translations: Partial<ITranslationContent>;
  readonly lang: string;
}

```

### Styles interface

```typescript theme={null}
interface NotificationCenterStyles {
  bellButton?: ObjectWithRoot<{
    dot?: CSSFunctionOrObject;
  }>;
  unseenBadge?: CSSFunctionOrObject;
  popover?: {
    arrow?: CSSFunctionOrObject;
    dropdown?: CSSFunctionOrObject;
  };
  loader?: ObjectWithRoot;
  layout?: ObjectWithRoot;
  header?: ObjectWithRoot<{
    title?: CSSFunctionOrObject;
    markAsRead?: CSSFunctionOrObject;
    cog?: CSSFunctionOrObject;
    backButton?: CSSFunctionOrObject;
  }>;
  tabs?: {
    tabsList?: CSSFunctionOrObject;
    tab?: CSSFunctionOrObject;
    tabLabel?: CSSFunctionOrObject;
    tabIcon?: CSSFunctionOrObject;
  };
  accordion?: {
    item?: CSSFunctionOrObject;
    content?: CSSFunctionOrObject;
    control?: CSSFunctionOrObject;
    chevron?: CSSFunctionOrObject;
  };
  switch?: ObjectWithRoot<{
    input?: CSSFunctionOrObject;
    track?: CSSFunctionOrObject;
    thumb?: CSSFunctionOrObject;
  }>;
  footer?: ObjectWithRoot<{
    title?: CSSFunctionOrObject;
  }>;
  notifications?: ObjectWithRoot<{
    listItem?: {
      read?: CSSFunctionOrObject;
      unread?: CSSFunctionOrObject;
      layout?: CSSFunctionOrObject;
      contentLayout?: CSSFunctionOrObject;
      title?: CSSFunctionOrObject;
      timestamp?: CSSFunctionOrObject;
      dotsButton?: CSSFunctionOrObject;
      buttons?: ObjectWithRoot<{
        primary?: CSSFunctionOrObject;
        secondary?: CSSFunctionOrObject;
      }>;
    };
  }>;
  actionsMenu?: {
    arrow?: CSSFunctionOrObject;
    dropdown?: CSSFunctionOrObject;
    item?: CSSFunctionOrObject;
  };
  preferences?: ObjectWithRoot<{
    item?: {
      title?: CSSFunctionOrObject;
      channels?: CSSFunctionOrObject;
      divider?: CSSFunctionOrObject;
      content?: {
        icon?: CSSFunctionOrObject;
        channelLabel?: CSSFunctionOrObject;
        success?: CSSFunctionOrObject;
      };
    };
  }>;
}

type CSSFunctionInterpolation = (args: {
  theme: INovuTheme;
  common: ICommonTheme;
  colorScheme: ColorScheme;
}) => CSSInterpolation;

type CSSFunctionOrObject = CSSFunctionInterpolation | CSSInterpolation;

type ObjectWithRoot<T = {}> = T & {
  root: CSSFunctionOrObject;
};
```

<Accordion title="How to use the Styles Interface?">
  To use the Styles Interface, you need to identify the property you need to modify to achieve your desired look and pass it as an object in the `styles` prop.

  <br />

  As listed in the [Styles Interface](/notification-center/client/react/api-reference#styles-interface), the notification center is made up of a number of components which can each be individually customized.

  <br />

  You can also check out our [docs on customizing styles](https://docs.novu.co/notification-center/client/react/api-reference#styles-interface) to see how to define styles for various components that make up the notification center.

  <br />

  #### Let's take an example to see this in action:

  By default, this is how the notification center looks:

  <Frame>
    <img />
  </Frame>

  Say, you wanted the text color to match the accent color. You just need to go over to the [docs on customizing styles](https://docs.novu.co/notification-center/client/react/api-reference#styles-interface) and find out which property needs to be modified. In our case, we need to change the `color` property as evident here:

  <Frame>
    <img />
  </Frame>

  Now, that we know which property needs to change, all we need to do is pass an object to the `styles` prop while maintaining the nesting of object keys:

  ```javascript theme={null}
  <div className='bell'>
      <NovuProvider
          subscriberId={process.env.REACT_APP_SUB_ID}
          applicationIdentifier={process.env.REACT_APP_APP_ID}

          styles={{ notifications: { listItem: { layout: { color: '#E3554D' } } } }}

      >
          <PopoverNotificationCenter >
              {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
          </PopoverNotificationCenter>
      </NovuProvider>
  </div >
  ```

  This gives us the desired result:

  <Frame>
    <img />
  </Frame>

  <Note>Please have a look at our [docs on customizing styles](https://docs.novu.co/notification-center/client/react/api-reference#styles-interface) to see how to define styles for various components of the notification center.</Note>
</Accordion>

### Fetching strategy interface

```typescript theme={null}
interface IFetchingStrategy {
  fetchUnseenCount: boolean;
  fetchOrganization: boolean;
  fetchNotifications: boolean;
  fetchUserPreferences: boolean;
}
```

## PopoverNotificationCenter

The floating popover component that appears when clicking on the [NotificationBell](#notificationbell) button. It renders the [NotificationCenter](#notificationcenter) component inside its content.

| Prop                       | Type                                            | Description                                                                                                                                                                                                  |
| -------------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| position                   | string (optional)                               | Position of the popover relative to the bell icon. It is based on the [Mantine Popover](https://mantine.dev/core/popover/?t=props). The default is set to `bottom-end`.                                      |
| offset                     | number (optional)                               | Gap between the Bell icon and Popover in px.                                                                                                                                                                 |
| colorScheme                | string                                          | The UI light or dark mode.                                                                                                                                                                                   |
| theme                      | [INovuTheme](#the-theme-interface) (optional)   | The theme object allowing you to override light and dark colors of the UI components. Deprecated for styling, please use the [styles](#styles-interface) prop on the NovuProvider.                           |
| tabs                       | [ITab](#the-tab-interface)(optional)            | Allows to define separate UI tabs for the notifications feed. The array of connection objects between the feed tab and [stores](#store-interface) (that you define on the NovuProvider) and feed identifier. |
| listItem                   | [ListItem](#the-list-item-interface) (optional) | The render function allowing you to define the custom element for the notification list item.                                                                                                                |
| showUserPreferences        | boolean (optional)                              | The flag that enables to show/hide the user preferences. By default it is enabled.                                                                                                                           |
| allowedNotificationActions | boolean (optional)                              | The flag that enables to show/hide the dots menu for actions performed on a notification. By default it is enabled.                                                                                          |
| onUrlChange                | function (optional)                             | The function that is called when the notification item has a CTA of type redirect and is clicked.                                                                                                            |
| onNotificationClick        | function (optional)                             | The function that is called when the notification item is clicked.                                                                                                                                           |
| onUnseenCountChanged       | function (optional)                             | The function that is called when the unseen notifications count changed.                                                                                                                                     |
| children                   | function                                        | The render function that allows you to define the custom bell button. It's called with an argument that has unseenCount prop the number of unseen notifications.                                             |
| header                     | function (optional)                             | The render function that allows you to define the custom header component.                                                                                                                                   |
| footer                     | function (optional)                             | The render function that allows you to define the custom footer component.                                                                                                                                   |
| emptyState                 | JSX.Element (optional)                          | The render function that allows you to define the custom component for the empty notifications list state.                                                                                                   |
| onActionClick              | function (optional)                             | The callback function triggered when the notification button is clicked.                                                                                                                                     |
| actionsResultBlock         | function (optional)                             | The render function that allows you to define the custom component that will be rendered after the notification button is clicked.                                                                           |
| onTabClick                 | function (optional)                             | The callback function triggered when the notifications feed tab changes.                                                                                                                                     |
| preferenceFilter           | function (optional)                             | The callback function triggered when filtering the subscriber preference.                                                                                                                                    |

### Props interface

```typescript theme={null}
interface IPopoverNotificationCenterProps {
  position?: PopoverProps["position"];
  offset?: number;
  colorScheme: ColorScheme;
  theme?: INovuThemePopoverProvider;
  tabs?: ITab[];
  listItem?: ListItem;
  showUserPreferences?: boolean;
  allowedNotificationActions?: boolean;
  onUrlChange?: (url: string) => void;
  onNotificationClick?: (notification: IMessage) => void;
  onUnseenCountChanged?: (unseenCount: number) => void;
  children: (props: INotificationBellProps) => JSX.Element;
  header?: () => JSX.Element;
  footer?: () => JSX.Element;
  emptyState?: JSX.Element;
  onActionClick?: (
    templateIdentifier: string,
    type: ButtonTypeEnum,
    message: IMessage
  ) => void;
  actionsResultBlock?: (
    templateIdentifier: string,
    messageAction: IMessageAction
  ) => JSX.Element;
  onTabClick?: (tab: ITab) => void;
  preferenceFilter?: (userPreference: IUserPreferenceSettings) => boolean;
}
```

More information about the [IMessage](#the-notification-imessage-model) interface, and the [theme](#the-theme-interface) interface.

### The tab interface

```typescript theme={null}
interface ITab {
  name: string;
  storeId: string;
}
```

### The list item interface

```typescript theme={null}
type ListItem = (
  message: IMessage,
  onActionButtonClick: (actionButtonType: ButtonTypeEnum) => void,
  onNotificationClick: () => void
) => JSX.Element;
```

## NotificationCenter

The component that renders the notifications feed and allows to update the user preferences.

| Prop                       | Type                                            | Description                                                                                                                                                                                                  |
| -------------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| colorScheme                | string                                          | The UI light or dark mode.                                                                                                                                                                                   |
| theme                      | [INovuTheme](#the-theme-interface) (optional)   | The theme object allowing you to override light and dark colors of the UI components. Deprecated for styling, please use the [styles](#styles-interface) prop on the NovuProvider.                           |
| tabs                       | [ITab](#the-tab-interface)(optional)            | Allows to define separate UI tabs for the notifications feed. The array of connection objects between the feed tab and [stores](#store-interface) (that you define on the NovuProvider) and feed identifier. |
| listItem                   | [ListItem](#the-list-item-interface) (optional) | The render function allowing you to define the custom element for the notification list item.                                                                                                                |
| showUserPreferences        | boolean (optional)                              | The flag that enables to show/hide the user preferences. By default it is enabled.                                                                                                                           |
| allowedNotificationActions | boolean (optional)                              | The flag that enables to show/hide the dots menu for actions performed on a notification. By default it is enabled.                                                                                          |
| onUrlChange                | function (optional)                             | The function that is called when the notification item has a CTA of type redirect and is clicked.                                                                                                            |
| onNotificationClick        | function (optional)                             | The function that is called when the notification item is clicked.                                                                                                                                           |
| onUnseenCountChanged       | function (optional)                             | The function that is called when the unseen notifications count changed.                                                                                                                                     |
| header                     | function (optional)                             | The render function that allows you to define the custom header component.                                                                                                                                   |
| footer                     | function (optional)                             | The render function that allows you to define the custom footer component.                                                                                                                                   |
| emptyState                 | JSX.Element (optional)                          | The render function that allows you to define the custom component for the empty notifications list state.                                                                                                   |
| onActionClick              | function (optional)                             | The callback function triggered when the notification button is clicked.                                                                                                                                     |
| actionsResultBlock         | function (optional)                             | The render function that allows you to define the custom component that will be rendered after the notification button is clicked.                                                                           |
| onTabClick                 | function (optional)                             | The callback function triggered when the notifications feed tab changes.                                                                                                                                     |
| preferenceFilter           | function (optional)                             | The callback function triggered when filtering the subscriber preference.                                                                                                                                    |

### Props interface

```typescript theme={null}
interface INotificationCenterProps {
  colorScheme: ColorScheme;
  theme?: INovuThemeProvider;
  tabs?: ITab[];
  listItem?: ListItem;
  showUserPreferences?: boolean;
  allowedNotificationActions?: boolean;
  onUrlChange?: (url: string) => void;
  onNotificationClick?: (notification: IMessage) => void;
  onUnseenCountChanged?: (unseenCount: number) => void;
  header?: () => JSX.Element;
  footer?: () => JSX.Element;
  emptyState?: JSX.Element;
  onActionClick?: (
    templateIdentifier: string,
    type: ButtonTypeEnum,
    message: IMessage
  ) => void;
  actionsResultBlock?: (
    templateIdentifier: string,
    messageAction: IMessageAction
  ) => JSX.Element;
  onTabClick?: (tab: ITab) => void;
  preferenceFilter?: (userPreference: IUserPreferenceSettings) => boolean;
}
```

## NotificationBell

The component that renders the notification bell with the unseen notifications count.

| Prop                       | Type                        | Description                                                  |
| -------------------------- | --------------------------- | ------------------------------------------------------------ |
| unseenCount                | number (optional)           | The number of unseen notifications.                          |
| unseenBadgeColor           | string or object (optional) | The unseen notifications count badge color.                  |
| unseenBadgeBackgroundColor | string (optional)           | The background color of the notification unseen count badge. |
| colorScheme                | string (optional)           | The UI light or dark mode.                                   |

### Props interface

```typescript theme={null}
interface INotificationBellProps {
  unseenCount?: number;
  unseenBadgeColor?: string | ISvgStopColor;
  unseenBadgeBackgroundColor?: string;
  colorScheme?: ColorScheme;
}

interface ISvgStopColor {
  stopColor?: string;
  stopColorOffset?: string;
}
```

## Hooks

### useNotifications

This hook that allows you to get the notifications feed data and unseen notifications count. The notifications are fetched only when the `fetchingStrategy.fetchNotifications` is set to true interface, check the `initialFetchingStrategy` prop on the [NovuProvider](#novuprovider) component.

```typescript theme={null}
const result = useNotifications();
```

`useNotifications` hook return interface

```typescript theme={null}
interface INotificationsContext {
  storeId: string;
  storeQuery: IStoreQuery;
  stores: IStore[];
  unseenCount: number;
  notifications: IMessage[];
  hasNextPage: boolean;
  isLoading: boolean;
  isFetching: boolean;
  isFetchingNextPage: boolean;
  setStore: (storeId?: string) => void;
  fetchNextPage: () => void;
  refetch: () => void;
  markNotificationAsRead: (messageId: string) => void;
  markNotificationAsUnRead: (messageId: string) => void;
  markNotificationAsSeen: (messageId: string) => void;
  markFetchedNotificationsAsRead: () => void;
  markFetchedNotificationsAsSeen: () => void;
  markAllNotificationsAsRead: () => void;
  markAllNotificationsAsSeen: () => void;
  removeMessage: (messageId: string) => void;
  removeAllMessages: (feedId?: string) => void;
}
```

Description of the `useNotifications` hook return interface properties

| Prop                           | Type                                             | Description                                                                                                           |
| ------------------------------ | ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| storeId                        | string                                           | active `storeId`                                                                                                      |
| stores                         | [IStore\[\]](#store-interface)                   | array of [IStore](#store-interface) passed to the [NovuProvider](#novuprovider).                                      |
| unseenCount                    | number                                           | unseen notifications (messages) count.                                                                                |
| notifications                  | [IMessage\[\]](#the-notification-imessage-model) | The feed notifications array.                                                                                         |
| hasNextPage                    | boolean                                          | flag indicating if the next notifications page to fetch is available.                                                 |
| isLoading                      | boolean                                          | flag indicating if the initial notifications fetch request is on the fly.                                             |
| isFetching                     | boolean                                          | flag indicating if the notifications are fetching including initial fetch.                                            |
| isFetchingNextPage             | boolean                                          | flag indicating if the next notifications page request in on the fly.                                                 |
| setStore                       | function                                         | function used to change the current notifications [IStore](#store-interface)                                          |
| fetchNextPage                  | function                                         | function that fires the fetch request for the next notifications page.                                                |
| refetch                        | function                                         | function used to refetch all the notifications, when multiple page requests were made it will refetch all of them.    |
| markNotificationAsRead         | function                                         | function takes the notification (message) `messageId` as an argument and marks that notification (message) as read.   |
| markNotificationAsUnRead       | function                                         | function takes the notification (message) `messageId` as an argument and marks that notification (message) as unread. |
| markNotificationAsSeen         | function                                         | function takes the notification (message) `messageId` as an argument and marks that notification (message) as seen.   |
| markFetchedNotificationsAsRead | function                                         | function marks all the fetched notifications as read.                                                                 |
| markFetchedNotificationsAsSeen | function                                         | function allowing you to mark all the fetched notifications as seen.                                                  |
| markAllNotificationsAsRead     | function                                         | function allowing you to mark all notifications as read.                                                              |
| markAllNotificationsAsSeen     | function                                         | function allowing you to mark notifications as seen.                                                                  |
| removeMessage                  | function                                         | function takes the notification (message) `messageId` as an argument and delete a notification.                       |
| removeAllMessages              | function                                         | The function allowing you to delete all notifications or a specific feed's (store's) notifications at once.           |

### useFetchNotifications

`useFetchNotifications` can fetche the notifications for a particular feed. It's a thin version of the `useNotifications` hook and is based on the `useInfiniteQuery` hook from the `react-query` library. Notifications can be filtered using `payload` property. Check all properties of [IStoreQuery](#store-interface) interface. The notifications are fetched only when the `fetchingStrategy.fetchNotifications` is set to true interface, check the `initialFetchingStrategy` prop on the [NovuProvider](#novuprovider) component.

```typescript theme={null}
const query: IStoreQuery = {
  limit: 10,
  payload: {
    key: "value"
  }
};

const onSuccess = (data: IPaginatedResponse<IMessage>) => {};

const onError = (error: Error) => {};

const {
  data: notificationsPages,
  hasNextPage,
  isLoading,
  isFetching,
  isFetchingNextPage,
  fetchNextPage,
  refetch,
} = useFetchNotifications({ query }, { onSuccess, onError });
```

`useFetchNotifications` hook return args

```typescript theme={null}
interface IUseFetchNotificationsArgs {
  onSuccess?: (data: IPaginatedResponse<IMessage>) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useInfiniteQuery hook
}

```

`useFetchNotifications` hook return interface

```typescript theme={null}
interface InfiniteData<TData> {
  pages: TData[];
  pageParams: unknown[];
}

interface IUseUnseenCountResult {
  data: InfiniteData<IPaginatedResponse<IMessage>>;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useInfiniteQuery hook result
}
```

### useUnseenCount

`useUnseenCount` returns the total unseen notifications count. Under the hood it uses the socket connection to get the unseen count updates.

```typescript theme={null}
interface ICountData {
  count: number;
}

const onSuccess = ({ count }: ICountData) => {};

const onError = (error: Error) => {};

const { data, isLoading, isError, error } = useUnseenCount({ onSuccess, onError });
```

`useUnseenCount` hook args interface

```typescript theme={null}
interface IUseUnseenCountArgs {
  onSuccess?: (data: ICountData) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useUnseenCount` hook return interface

```typescript theme={null}
interface IUseUnseenCountResult {
  data?: ICountData;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useSocket

`useSocket` hooks is used to get the reference to socket object.

```typescript theme={null}
const { socket } = useSocket();
```

`useSocket` return interface

```typescript theme={null}
interface ISocket {
  on: (eventName: string, callback: (data: any) => void) => void;
  off: (eventName: string) => void;
}
```

`useSocket` supported events

| Event                  | Description                                              |
| ---------------------- | -------------------------------------------------------- |
| notification\_received | Triggered when a new notification is received            |
| unseen\_count\_changed | Triggered when the count of unseen notifications changes |
| unread\_count\_changed | Triggered when the count of unread notifications changes |

### useNovuContext

`useNovuContext` hook is used to get the reference to the [NovuProvider](#novuprovider) context.

```typescript theme={null}
const result = useNovuContext();
```

`useNovuContext` hook return interface

```typescript theme={null}
interface INovuProviderContext {
  backendUrl?: string;
  subscriberId?: string;
  applicationIdentifier?: string;
  isSessionInitialized: boolean;
  socketUrl?: string;
  subscriberHash: string;
  apiService: ApiService;
  socket?: ISocket;
  fetchingStrategy: IFetchingStrategy;
  setFetchingStrategy: (strategy: Partial<IFetchingStrategy>) => void;
  onLoad: (data: { organization: IOrganizationEntity }) => void;
}
```

### useFeedUnseenCount

`useFeedUnseenCount` hook fetches the unseen count for a particular feed.

```typescript theme={null}
interface ICountData {
  count: number;
}

const query: IStoreQuery = {
  feedIdentifier: "product-updates"
};

const onSuccess = (data: ICountData) => {};

const onError = (error: Error) => {};

const result = useFeedUnseenCount({ query }, { onSuccess, onError });
```

`useFeedUnseenCount` hook args interface

```typescript theme={null}
interface IUseFeedUnseenCountArgs {
  onSuccess?: (data: ICountData) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useFeedUnseenCount` hook return interface

```typescript theme={null}
interface IUseFeedUnseenCountResult {
  data?: ICountData;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useFetchOrganization

`useFetchOrganization` hok fetches the current organization information.

```typescript theme={null}
interface IOrganizationEntity {
  _id: string;
  name: string;
  members: {
    _id: string;
    _userId?: string;
    user?: Pick<IUserEntity, 'firstName' | '_id' | 'lastName' | 'email'>;
    roles: MemberRoleEnum[];
    invite?: IMemberInvite;
    memberStatus: MemberStatusEnum;
  }[];
  branding?: {
    color: string;
    logo: string;
    fontColor: string;
    fontFamily: string;
    contentBackground: string;
    direction: 'ltr' | 'rtl';
  };
}

const onSuccess = (data: IOrganizationEntity) => {};

const onError = (error: Error) => {};

const result = useFetchOrganization({ onSuccess, onError });
```

`useFetchOrganization` hook args interface

```typescript theme={null}
interface IUseFetchOrganizationArgs {
  onSuccess?: (data: IOrganizationEntity) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useFetchOrganization` hook return interface

```typescript theme={null}
interface IUseFetchOrganizationResult {
  data?: IOrganizationEntity;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useFetchUserPreferences

`useFetchUserPreferences` hook fetches the user preferences.

```typescript theme={null}
const onSuccess = (data: IUserPreferenceSettings[]) => {};

const onError = (error: Error) => {};

const result = useFetchUserPreferences({ onSuccess, onError });
```

`useFetchUserPreferences` hook args interface

```typescript theme={null}
interface IUseFetchUserPreferencesArgs {
  onSuccess?: (data: IUserPreferenceSettings[]) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useFetchUserPreferences` hook return interface

```typescript theme={null}
interface IUseFetchUserPreferencesResult {
  data?: IUserPreferenceSettings[];
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useUpdateUserPreferences

`useUpdateUserPreferences` hook is used to update the user preferences.

```typescript theme={null}
interface IPreferenceChannels {
  email?: boolean;
  sms?: boolean;
  in_app?: boolean;
  chat?: boolean;
  push?: boolean;
}

interface IUserPreferenceSettings {
  template: { _id: string; name: string; critical: boolean };
  preference: { enabled: boolean; channels: IPreferenceChannels };
}

const onSuccess = (data: IUserPreferenceSettings) => {};

const onError = (error: Error) => {};

const { updateUserPreferences, isLoading, isError, error } = useUpdateUserPreferences({
  onSuccess,
  onError,
});
```

`useUpdateUserPreferences` hook args interface

```typescript theme={null}
interface IUserPreferencesArgs {
  onSuccess?: (data: IUserPreferenceSettings) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useUpdateUserPreferences` hook return interface

```typescript theme={null}
interface IUpdateUserPreferencesVariables {
  templateId: string; // workflowId of mongodbId type
  channelType: string;
  checked: boolean;
}

interface IUserPreferencesResult {
  updateUserPreferences: (variables: IUpdateUserPreferencesVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useUpdateAction

`useUpdateAction` hook can be used to update the notification action button status.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { updateAction, isLoading, isError, error } = useUpdateAction({ onSuccess, onError });
```

`useUpdateAction` hook args interface

```typescript theme={null}
interface IUseUpdateActionArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useUpdateAction` hook return interface

```typescript theme={null}
interface IUpdateActionVariables {
  messageId: string;
  actionButtonType: ButtonTypeEnum;
  status: MessageActionStatusEnum;
  payload?: Record<string, unknown>;
}

interface IUpdateActionResult {
  updateAction: (variables: IUpdateActionVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useMarkNotificationsAs

`useMarkNotificationsAs` hook that marks the notifications as read or seen.

```typescript theme={null}
const onSuccess = (data: IMessage[]) => {};

const onError = (error: Error) => {};

const { markNotificationsAs, isLoading, isError, error } = useMarkNotificationsAs({
  onSuccess,
  onError,
});
```

`useMarkNotificationsAs` hook args interface

```typescript theme={null}
interface IUseMarkNotificationsAsArgs {
  onSuccess?: (data: IMessage[]) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useMarkNotificationsAs` hook return interface

```typescript theme={null}
interface IMarkNotificationsAsVariables {
  messageId: IMessageId;
  seen: boolean;
  read: boolean;
}

interface IUseMarkNotificationsAsResult {
  markNotificationsAs: (args: IMarkNotificationsAsVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useRemoveNotification

`useRemoveNotification` hook allows you to remove a message. It will delete the message for the subscriber and will refetch the feed.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { removeNotification, isLoading, isError, error } = useRemoveNotification({
  onSuccess,
  onError,
});
```

`useRemoveNotification` hook args interface

```typescript theme={null}
interface IUseRemoveNotificationArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useRemoveNotification` hook return interface

```typescript theme={null}
interface IRemoveNotificationVariables {
  messageId: IMessageId;
}

interface IUseRemoveNotificationResult {
  removeNotification: (args: IRemoveNotificationVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useRemoveNotifications

<Note>This hook is available from version 0.23.1</Note>

`useRemoveNotifications` hook allows you to remove multiple messages with a limit of 100 messageIds in single call.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { removeNotifications, isLoading, isError, error } = useRemoveNotifications({
  onSuccess,
  onError,
});
```

`useRemoveNotifications` hook args interface

```typescript theme={null}
interface IUseRemoveNotificationArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useRemoveNotifications` hook return interface

```typescript theme={null}
interface IRemoveNotificationsVariables {
  messageIds: string[];
}

interface IUseRemoveNotificationResult {
  removeNotifications: (args: IRemoveNotificationsVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useRemoveAllNotifications

`useRemoveAllNotifications` hook allows you to remove all messages of all feeds. feedId can be used as param to delete only specific feed's messages.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { removeAllNotifications, isLoading, isError, error } = useRemoveAllNotifications({
  onSuccess,
  onError,
});
```

`useRemoveAllNotifications` hook args interface

```typescript theme={null}
interface IUseRemoveAllNotificationsArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useRemoveAllNotifications` hook return interface

```typescript theme={null}
interface IRemoveAllNotificationsVariables {
  feedId?: string;
}

interface IUseRemoveAllNotificationsResult {
  removeAllNotifications: (args: IRemoveAllNotificationsVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useTranslations

`useTranslations` hook allows you to get the reference to the [translations](/notification-center/client/react/customization#customize-the-ui-language) object.

```typescript theme={null}
const result = useTranslations();
```

`useTranslations` returns interface

```typescript theme={null}
interface ITranslations {
  lang: string;
  t: (key: string) => string;
  dateFnsLocale: () => Locale;
}
```

### useNovuTheme

`useNovuTheme` hook can be used to get the reference to the [theme](#the-theme-interface) object.

```typescript theme={null}
const result = useNovuTheme();
```

`useNovuTheme` hook return interface

```typescript theme={null}
interface INovuThemeProviderContext {
  theme: INovuTheme;
  common: ICommonTheme;
  colorScheme: ColorScheme;
}
```

#### The theme interface

```typescript theme={null}
interface INovuTheme {
  layout?: IThemeLayout;
  header?: IThemeHeader;
  popover?: IThemePopover;
  actionsMenu?: IThemeActionsMenu;
  notificationItem?: IThemeNotificationListItem;
  userPreferences?: IThemeUserPreferences;
  footer?: IThemeFooter;
  loaderColor?: string;
}
```

#### `IThemeLayout`

| Property                   | Default Value (Light Theme)            | Default Value - (Dark Theme)    |
| -------------------------- | -------------------------------------- | ------------------------------- |
| background                 | #FFFFFF                                | #1E1E26                         |
| boxShadow                  | 0px 5px 15px rgba(122, 133, 153, 0.25) | 0px 5px 20px rgba(0, 0, 0, 0.2) |
| wrapper.secondaryFontColor | #BEBECC                                | #525266                         |

#### `IThemeHeader`

| Property       | Default Value (Light Theme)                   | Default Value - (Dark Theme)                  |
| -------------- | --------------------------------------------- | --------------------------------------------- |
| badgeColor     | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) |
| badgeTextColor | #FFFFFF                                       | #FFFFFF                                       |
| fontColor      | #828299                                       | #FFFFFF                                       |

#### `IThemePopover`

| Property   | Default Value (Light Theme) | Default Value - (Dark Theme) |
| ---------- | --------------------------- | ---------------------------- |
| arrowColor | #FFFFFF                     | #1E1E26                      |

#### `IThemeNotificationListItem`

| Property                                | Default Value (Light Theme)                             | Default Value - (Dark Theme)                            |
| --------------------------------------- | ------------------------------------------------------- | ------------------------------------------------------- |
| seen.fontColor                          | #828299                                                 | #FFFFFF                                                 |
| seen.background                         | #F5F8FA                                                 | #23232B                                                 |
| seen.timeMarkFontColor                  | #BEBECC                                                 | #525266                                                 |
| unseen.fontColor                        | #828299                                                 | #FFFFFF                                                 |
| unseen.background                       | #FFFFFF                                                 | #292933                                                 |
| unseen.boxShadow                        | 0px 5px 15px rgba(122, 133, 153, 0.25)                  | 0px 5px 20px rgba(0, 0, 0, 0.2)                         |
| unseen.notificationItemBeforeBrandColor | linear-gradient(0deg,#FF512F 0%,#DD2476 100%)           | linear-gradient(0deg,#FF512F 0%,#DD2476 100%)           |
| unseen.timeMarkFontColor                | #828299                                                 | #828299                                                 |
| buttons.primary.backGroundColor         | linear-gradient(99deg,#DD2476 0% 0%, #FF512F 100% 100%) | linear-gradient(99deg,#DD2476 0% 0%, #FF512F 100% 100%) |
| buttons.primary.fontColor               | #FFFFFF                                                 | #FFFFFF                                                 |
| buttons.primary.removeCircleColor       | white                                                   | white                                                   |
| buttons.primary.fontFamily              | inherit                                                 | inherit                                                 |
| buttons.secondary.backGroundColor       | #F5F8FA                                                 | #3D3D4D                                                 |
| buttons.secondary.fontColor             | #525266                                                 | #FFFFFF                                                 |
| buttons.secondary.removeCircleColor     | #525266                                                 | #525266                                                 |
| buttons.secondary.fontFamily            | inherit                                                 | inherit                                                 |

#### `IThemeActionsMenu`

| Property        | Default Value (Light Theme) | Default Value - (Dark Theme) |
| --------------- | --------------------------- | ---------------------------- |
| dotsButtonColor | #A1A1B2                     | #525266                      |
| dropdownColor   | #FFFFFF                     | #292933                      |
| hoverColor      | #F5F8FA                     | #3D3D4D                      |
| fontColor       | #525266                     | #FFFFFF                      |

#### `IThemeUserPreferences`

| Property                                   | Default Value (Light Theme)                   | Default Value - (Dark Theme)                  |
| ------------------------------------------ | --------------------------------------------- | --------------------------------------------- |
| `settingsButtonColor`                      | #A1A1B2                                       | #525266                                       |
| `accordion.background`                     | #FFFFFF                                       | #292933                                       |
| `accordion.fontColor`                      | #525266                                       | #FFFFFF                                       |
| `accordion.secondaryFontColor`             | #828299                                       | #828299                                       |
| `accordion.boxShadow`                      | 0px 5px 15px rgba(122, 133, 153, 0.25)        | 0px 5px 20px rgba(0, 0, 0, 0.2)               |
| `accordion.arrowColor`                     | #828299                                       | #828299                                       |
| `accordion.arrowColor`                     | #EDF0F2                                       | #3D3D4D                                       |
| `accordionItem.fontColor.active`           | #525266                                       | #FFFFFF                                       |
| `accordionItem.fontColor.inactive`         | #BEBECC                                       | #828299                                       |
| `accordionItem.icon.active`                | #525266                                       | #FFFFFF                                       |
| `accordionItem.icon.inactive`              | #BEBECC                                       | #525266                                       |
| `accordionItem.switch.backgroundChecked`   | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) |
| `accordionItem.switch.backgroundUnchecked` | #BEBECC                                       | #3D3D4D                                       |
| `footer.logoTextColor`                     | #000000                                       | #FFFFFF                                       |
| `footer.logoPrefixFontColor`               | #A1A1B2                                       | #525266                                       |
| `loaderColor`                              | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) |

#### `IThemeFooter`

| Property            | Default Value (Light Theme) | Default Value - (Dark Theme) |
| ------------------- | --------------------------- | ---------------------------- |
| logoTextColor       | #000000                     | #FFFFFF                      |
| logoPrefixFontColor | #A1A1B2                     | #525266                      |

customization properties

| Property                   | type                                      | Default Value (Light Theme) | Default Value - (Dark Theme) |
| -------------------------- | ----------------------------------------- | --------------------------- | ---------------------------- |
| colorScheme                | string                                    | light                       | light                        |
| unseenBadgeColor           | string or [ISvgStopColor](#isvgstopcolor) | -                           | -                            |
| unseenBadgeBackgroundColor | string                                    | #FFFFFF                     | #1E1E26                      |

#### `ISvgStopColor`

| Property        | Default Value (Light Theme) | Default Value - (Dark Theme) |
| --------------- | --------------------------- | ---------------------------- |
| stopColor       | #FF512F                     | #FF512F                      |
| stopColorOffset | #DD2476                     | #DD2476                      |

## Others

### The notification `IMessage` model

`IMessage` model has the following properties:

| Property                  | Type                                      | Description                                                                                          |
| ------------------------- | ----------------------------------------- | ---------------------------------------------------------------------------------------------------- |
| \_id                      | string                                    | A unique Novu message identifier                                                                     |
| channel                   | [ChannelTypeEnum](#channeltypeenum)       | Use to specify the actual channel of this message (in\_app will be used here)                        |
| seen                      | boolean                                   | Whether the notification item was read by the user, changed when the user clicks on the notification |
| lastSeenDate              | ISODate                                   | When the user has last seen the notification                                                         |
| content                   | string                                    | An HTML string of the generated notification content with parsed and replaced variables              |
| templateIdentifier        | string                                    | A unique Novu workflow identifier                                                                    |
| payload                   | `Record<string, unknown>`                 | The payload object that was passed to the trigger even of the workflow.                              |
| createdAt                 | ISODate                                   | The creation date of the message                                                                     |
| cta.type                  | [ChannelCTATypeEnum](#channelctatypeenum) | The type of the CTA specified in the admin panel                                                     |
| cta.data.url              | string                                    | The redirect URL set in the admin panel, can be used to navigate on notification click               |
| cta.action.status         | boolean                                   | Indication whether the action occurred                                                               |
| cta.action.buttons        | [IMessageButton\[\]](#imessagebutton)     | Array of action buttons                                                                              |
| cta.action.result.payload | `Record<string, unknown>`                 | Payload object that send on updateAction method in useNotifications hook                             |
| cta.action.result.type    | [ButtonTypeEnum](#buttontypeenum)         | Type of the button                                                                                   |
| subscriber                | [SubscriberProps](#subscriberprops)       | Subscriber object that contains information about the subscriber                                     |

### SubscriberProps

| Property     | Type   | Description                                                         |
| ------------ | ------ | ------------------------------------------------------------------- |
| \_id         | string | Auto-generated identifier for the subscriber entity in the database |
| firstName    | string | First name of the subscriber                                        |
| subscriberId | string | identifier of the subscriber entity in the Novu Web Dashboard       |

### IMessageButton

| Property | Type                              | Description       |
| -------- | --------------------------------- | ----------------- |
| type     | [ButtonTypeEnum](#buttontypeenum) | Button type enum  |
| content  | string                            | Button inner text |

### ChannelCTATypeEnum

| Property | Value    |
| -------- | -------- |
| REDIRECT | redirect |

### ChannelTypeEnum

| Property | Value   |
| -------- | ------- |
| IN\_APP  | in\_app |
| EMAIL    | email   |
| SMS      | sms     |
| CHAT     | chat    |
| PUSH     | push    |

### ButtonTypeEnum

| Property  | Value     |
| --------- | --------- |
| PRIMARY   | primary   |
| SECONDARY | secondary |


# Customizing Notification Center
Source: https://v0.x-docs.novu.co/notification-center/client/react/customization

Learn how to customize the pre built notification center component partially or building your own notification center component from scratch using Novu provided hooks

## PopoverNotificationCenter Customization

`<PopoverNotificationCenter>` is a pre built notification center component that can be used to show notifications in your application. It is a popover component that can be placed anywhere in your application. A bell will appear on the page. On click of that bell, a popover will appear. Checkout all customizations and available [props](/notification-center/client/react/api-reference#popovernotificationcenter). If you are looking for a component without popover use regular `<NotificationCenter>` component. Checkout [props](/notification-center/client/react/api-reference#notificationcenter) of this component. Few selected customization options are explained below:-

### Implementing custom bell icon

It is common that you might have a special set of icons you use within your application and you will want to replace the default: `NotificationBell` coming from our library.

For this you can easily switch the `NotificationBell` with your own bell. Just make sure you pass the `unseenCount` param inside and use it accordingly.

```jsx theme={null}
<PopoverNotificationCenter colorScheme="dark">
  {({ unseenCount }) => (
    <CustomBell
      unseenCount={unseenCount}
      colorScheme="dark"
      unseenBadgeBackgroundColor="#FFFFFF"
      unseenBadgeColor="#FF0000"
    />
  )}
</PopoverNotificationCenter>
```

### Dark mode support

To support dark mode in your application the notification center component can receive a `colorScheme` prop that can receive either `dark` or `light` mode.

```tsx theme={null}
<PopoverNotificationCenter colorScheme={"dark" || "light"}>
  {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
</PopoverNotificationCenter>
```

### Popover positioning

Use `position`  and `offset` prop to position the popover relative to the Bell icon

```jsx theme={null}
<PopoverNotificationCenter position="left-start" offset={20}>
  {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
</PopoverNotificationCenter>
```

### Header, Footer and Empty state

Use `header`, `footer` and `emptyState` prop to customize the header, footer and empty state of notification center.

```jsx theme={null}
const Header = () => {
  return <span> My custom header </span>;
};

const Footer = () => {
  return <span> My custom footer </span>;
};

const EmptyState = () => {
  return <span> My custom empty state </span>;
};

<PopoverNotificationCenter
  colorScheme="dark"
  header={() => <Header />}
  footer={() => <Footer />}
  emptyState={<EmptyState />}
>
  {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
</PopoverNotificationCenter>;
```

### Notification item

Use the listItem prop to show custom notification items.

```jsx theme={null}
<PopoverNotificationCenter
  colorScheme={colorScheme}
  onNotificationClick={handlerOnNotificationClick}
  onActionClick={handlerOnActionClick}
  listItem={(
    notification,
    handleActionButtonClick,
    handleNotificationClick
  ) => {
    return (
      <a
        href="/"
        onClick={(e) => {
          e.preventDefault();
          handleNotificationClick();
        }}
      >
        {notification.content}
      </a>
    );
  }}
>
  {({ unseenCount }) => {
    return <NotificationBell unseenCount={unseenCount} />;
  }}
</PopoverNotificationCenter>
```

### Customize the UI language

If you want to use a language other than english for the UI, the `NovuProvider` component can accept an optional `i18n` prop.

```typescript theme={null}
<NovuProvider
  subscriberId={"USER_ID"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
  i18n="en"
>
  <PopoverNotificationCenter colorScheme="dark">
    {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
  </PopoverNotificationCenter>
</NovuProvider>
```

The `i18n` prop can accept 2 different types of values

* 2 letter language string

```typescript theme={null}
i18n = "en";
```

<Accordion title="Supported Language">
  * `af` (Afrikaans)
  * `am` (Amharic)
  * `ar` (Arabic)
  * `as` (Assamese)
  * `az` (Azerbaijani)
  * `ba` (Bashkir)
  * `be` (Belarusian)
  * `bg` (Bulgarian)
  * `bh` (Bihari)
  * `bn` (Bengali)
  * `bs` (Bosnian)
  * `ca` (Catalan)
  * `cs` (Czech)
  * `da` (Danish)
  * `de` (German)
  * `el` (Greek)
  * `en` (English)
  * `es` (Spanish)
  * `eu` (Basque)
  * `fa` (Farsi)
  * `fi` (Finnish)
  * `fr` (French)
  * `ga` (Irish)
  * `gl` (Galician)
  * `gu` (Gujarati)
  * `he` (Hebrew)
  * `hi` (Hindi)
  * `hr` (Croatian)
  * `hu` (Hungarian)
  * `hy` (Armenian)
  * `id` (Indonesian)
  * `ig` (Igbo)
  * `it` (Italian)
  * `ja` (Japanese)
  * `ka` (Kannada)
  * `kk` (Kazakh)
  * `km` (Khmer)
  * `ko` (Korean)
  * `ku` (Kurdish)
  * `lo` (Lao)
  * `lt` (Lithuanian)
  * `lv` (Latvian)
  * `ml` (Malayalam)
  * `mr` (Marathi)
  * `ms` (Malay)
  * `nb` (Norwegian)
  * `ne` (Nepali)
  * `nl` (Dutch)
  * `or` (Odia)
  * `pa` (Punjabi)
  * `pl` (Polish)
  * `pt` (Portuguese)
  * `ro` (Romanian)
  * `ru` (Russian)
  * `sa` (Sanskrit)
  * `sd` (Sindhi)
  * `si` (Sinhala)
  * `sm` (Samoan)
  * `sq` (Albanian)
  * `sv` (Swedish)
  * `sq` (Albanian)
  * `ta` (Tamil)
  * `te` (Telugu)
  * `th` (Thai)
  * `tl` (Tagalog)
  * `tr` (Turkish)
  * `uk` (Ukrainian)
  * `ur` (Urdu)
  * `uz` (Uzbek)
  * `vi` (Vietnamese)
  * `zh` (Chinese)
  * `zu` (Zulu)
</Accordion>

* Translation object

```typescript theme={null}
i18n={{
  // Make sure that the following is a proper language code,
  // since this is used by Intl.RelativeTimeFormat in order to calculate the relative time for each notification
  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
  lang: "de",

  translations: {
    poweredBy: "von",
    markAllAsRead: "Alles als gelesen markieren",
    notifications: "Benachrichtigungen",
    settings: "Einstellungen",
  },
}}

```

<Tip>Novu uses *`en`* as the default value for i18n</Tip>

### Customization using `styles` prop

`styles` prop can be used to cutomise styling of each component of notification center. Read more about [styles prop](/notification-center/client/react/api-reference#styles)

```javascript theme={null}
export const styles = {
  bellButton: {
    root: {
      marginTop: "20px",
      svg: {
        color: "#AFE1AF",
        fill: "white",
        minWidth: "20px",
        minHeight: "20px"
      }
    },
    dot: {
      rect: {
        fill: "white",
        strokeWidth: "0",
        width: "3px",
        height: "3px",
        x: 10,
        y: 2
      }
    }
  }
}
```

<Accordion title="Customizing styles">
  ```javascript theme={null}
  const primaryColor = "white";
  const secondaryColor = "#AFE1AF";
  const primaryTextColor = "#0C0404";
  const secondaryTextColor = "#494F55";
  const unreadBackGroundColor = "#869F9F";
  const primaryButtonBackGroundColor = unreadBackGroundColor;
  const secondaryButtonBackGroundColor = "#C6DFCD";
  const dropdownBorderStyle = "2px solid #AFE1AF";
  const tabLabelAfterStyle = "#AFE1AF !important";
  const ncWidth = "350px !important";

  export const styles = {
    bellButton: {
      root: {
        marginTop: "20px",
        svg: {
          color: secondaryColor,
          fill: primaryColor,
          minWidth: "20px",
          minHeight: "20px"
        }
      },
      dot: {
        rect: {
          fill: primaryColor,
          strokeWidth: "0",
          width: "3px",
          height: "3px",
          x: 10,
          y: 2
        }
      }
    },
    unseenBadge: {
      root: { color: primaryTextColor, background: secondaryColor }
    },
    popover: {
      root: { zIndex: -99 },
      arrow: {
        backgroundColor: primaryColor,
        borderLeftColor: secondaryColor,
        borderTopColor: secondaryColor
      },
      dropdown: {
        border: dropdownBorderStyle,
        borderRadius: "10px",
        marginTop: "25px",
        maxWidth: ncWidth
      }
    },
    header: {
      root: {
        backgroundColor: primaryColor,
        "&:hover": { backgroundColor: primaryColor },
        cursor: "pointer",
        color: primaryTextColor
      },
      cog: { opacity: 1 },
      markAsRead: {
        color: primaryTextColor,
        fontSize: "14px"
      },
      title: { color: primaryTextColor },
      backButton: {
        color: primaryTextColor
      }
    },
    layout: {
      root: {
        background: primaryColor,
        maxWidth: ncWidth
      }
    },
    loader: {
      root: {
        stroke: primaryTextColor
      }
    },
    accordion: {
      item: {
        backgroundColor: secondaryColor,
        ":hover": {
          backgroundColor: secondaryColor
        }
      },
      content: {
        backgroundColor: secondaryColor,
        borderBottomLeftRadius: "7px",
        borderBottomRightRadius: "7px"
      },
      control: {
        ":hover": {
          backgroundColor: secondaryColor
        },
        color: primaryTextColor,
        title: {
          color: primaryTextColor
        }
      },
      chevron: {
        color: primaryTextColor
      }
    },
    notifications: {
      root: {
        ".nc-notifications-list-item": {
          backgroundColor: secondaryColor
        }
      },
      listItem: {
        layout: {
          borderRadius: "7px",
          color: primaryTextColor,
          "div:has(> .mantine-Avatar-root)": {
            border: "none",
            width: "20px",
            height: "20px",
            minWidth: "20px"
          },
          ".mantine-Avatar-root": {
            width: "20px",
            height: "20px",
            minWidth: "20px"
          },
          ".mantine-Avatar-image": {
            width: "20px",
            height: "20px",
            minWidth: "20px"
          }
        },
        timestamp: { color: secondaryTextColor, fontWeight: "bold" },
        dotsButton: {
          path: {
            fill: primaryTextColor
          }
        },
        unread: {
          "::before": { background: unreadBackGroundColor }
        },
        buttons: {
          primary: {
            background: primaryButtonBackGroundColor,
            color: primaryTextColor,
            "&:hover": {
              background: primaryButtonBackGroundColor,
              color: secondaryTextColor
            }
          },
          secondary: {
            background: secondaryButtonBackGroundColor,
            color: secondaryTextColor,
            "&:hover": {
              background: secondaryButtonBackGroundColor,
              color: secondaryTextColor
            }
          }
        }
      }
    },
    actionsMenu: {
      item: { "&:hover": { backgroundColor: secondaryColor } },
      dropdown: {
        backgroundColor: primaryColor
      },
      arrow: {
        backgroundColor: primaryColor,
        borderTop: "0",
        borderLeft: "0"
      }
    },
    preferences: {
      item: {
        title: { color: primaryTextColor },
        divider: { borderTopColor: primaryColor },
        channels: { color: secondaryTextColor },
        content: {
          icon: { color: primaryTextColor },
          channelLabel: { color: primaryTextColor },
          success: { color: primaryTextColor }
        }
      }
    },
    tabs: {
      tabLabel: {
        "::after": { background: tabLabelAfterStyle },
        ":hover": { color: tabLabelAfterStyle },
        "[data-active]": { color: tabLabelAfterStyle }
      },
      tabsList: { borderBottomColor: primaryColor }
    }
  };
  ```
</Accordion>

[![Edit custom-styles-novu-nc](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/custom-styles-novu-nc-2jd46m?fontsize=14\&module=%2Fsrc%2Fstyles.js\&moduleview=1\&theme=dark)

## Customization Using Hooks

If you don't want to use our pre built component then, you can build your own notification center using hooks. `@novu/notification-center` react package provides many hooks like `useNotifications`, `useFetchNotifications`, `useUpdateUserPreferences`. Checkout all available [hooks](/notification-center/client/react/api-reference#hooks). All the hooks should be defined inside the [NovuProvider](/notification-center/client/react/api-reference#novuprovider) component. Most of the hooks are based on the `@tanstack/react-query` library.

Checkout below example on how to use `useNotifications` and `useFetchNotifications` hook
[![Edit useNotifications-useFetchNotifications-hook](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/usenotifications-usefetchnotifications-hook-2t6sgz?fontsize=14\&hidenavigation=1\&theme=dark)


# React Get Started
Source: https://v0.x-docs.novu.co/notification-center/client/react/get-started

Learn how to add novu powered In-App notification center to your React app

Novu provides the `@novu/notification-center` a React library that helps to add a fully functioning notification center to your web application in minutes. Let's do a quick recap on how you can easily use it in your application.

1. Install `@novu/notification-center` npm package in your react app

```jsx theme={null}
npm install @novu/notification-center
```

2. Add the below code in the app.tsx file

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
  IMessage,
} from "@novu/notification-center";

function Novu() {
  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <PopoverNotificationCenter colorScheme="dark">
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}
```

[![Edit kind-nova-xv6s9g](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark)

Go to this react app browser tab, there will be a bell icon. On clicking that bell icon, you will see a notification component popover

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Use your own backend and socket URL

By default, Novu's hosted services of API and socket are used. If you want, you can override them and configure your own.

```tsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
} from "@novu/notification-center";

function Novu() {
  return (
    <NovuProvider
      backendUrl={"YOUR_BACKEND_URL"}
      socketUrl={"YOUR_SOCKET_URL"}
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <PopoverNotificationCenter colorScheme="dark">
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}
```

## Notification center without bell

If you don't want to show the bell icon, you can directly render the notification center component without passing the bell, use `<NotificationCenter>` component in place of `<PopoverNotificationCenter>`

```jsx theme={null}
import {
  NovuProvider,
  NotificationCenter,
} from "@novu/notification-center";

<NovuProvider
  subscriberId={"SUBSCRIBER_ID"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
>
  <NotificationCenter colorScheme="dark" />
</NovuProvider>
```

## HMAC Encryption

When Novu's user adds the notification center to their application they are required to pass a `subscriberId` which identifies the user's end-customer, and the application Identifier which is acted as a public key to communicate with the notification feed API.

A malicious actor can access the user feed by accessing the API and passing another `subscriberId` using the public application identifier.

HMAC encryption will make sure that a `subscriberId` is encrypted using the secret API key, and those will prevent malicious actors from impersonating users.

### Enabling HMAC Encryption

In order to enable Hash-Based Message Authentication Codes, you need to visit the admin panel In-App settings page and enable HMAC encryption for your environment.

<Frame>
  <img />
</Frame>

1. Next step would be to generate an HMAC encrypted subscriberId on your backend:

```jsx theme={null}
import { createHmac } from "crypto";

const hmacHash = createHmac("sha256", process.env.NOVU_API_KEY)
  .update(subscriberId)
  .digest("hex");
```

2. Then pass the created HMAC to your client side application forward it to the component:

```jsx theme={null}
<NovuProvider
  subscriberId={"SUBSCRIBER_ID_PLAIN_VALUE"}
  subscriberHash={"SUBSCRIBER_ID_HASH_VALUE"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
>
  <NotificationCenter colorScheme="dark" />
</NovuProvider>
```

<Info>If HMAC encryption is active in In-App provider settings and  `subscriberHash` along with `subscriberId` is not provided, then notification center will not load</Info>

## Notification Actions

### onNotificationClick

This function is invoked when the user clicks anywhere on the notification except for CTA actions.

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
  IMessage,
} from "@novu/notification-center";

function Novu() {
  function handleOnNotificationClick(message: IMessage) {
    // your logic to handle the notification click
    if (message?.cta?.data?.url) {
      window.location.href = message.cta.data.url;
    }
  }

  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <PopoverNotificationCenter
        colorScheme="dark"
        onNotificationClick={handleOnNotificationClick}
      >
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}
```

### onActionClick

This function is invoked when the user clicks on the action CTA buttons of the notification

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  IMessage,
  MessageActionStatusEnum,
  useUpdateAction,
  ButtonTypeEnum,
  NotificationBell,
} from "@novu/notification-center";

export default function Novu() {

  const CustomNotificationCenter = () => {
    const { updateAction } = useUpdateAction();

    const handleOnActionClick = async (
      templateIdentifier: string,
      btnType: ButtonTypeEnum,
      notification: IMessage
    ) => {
      if (templateIdentifier === "friend-request") {
        if (btnType === "primary") {
          /** Call your API to accept the friend request here **/

          /** And then update Novu that this action has been taken, so the user won't see the button again **/
          updateAction({
            messageId: notification._id,
            actionButtonType: btnType,
            status: MessageActionStatusEnum.DONE,
          });
        }
      }
    };

    return (
      <PopoverNotificationCenter
        colorScheme={"dark"}
        onActionClick={handleOnActionClick}
      >
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    );
  };

  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <CustomNotificationCenter />
    </NovuProvider>
  );
}
```

<Note>CTA buttons text and redirect url field supports dynamic variables</Note>

## Avatar Icons

Avatar images can be shown with in-app notifications. To do so, enable `Add an Avatar` option in in-app step editor as shown below

<Frame>
  <img />
</Frame>

**There are 3 ways to show the avatar images in the notifications:**

<Frame>
  <img />
</Frame>

### User Avatar

This option will show the avatar of the actor user. actor field can be sent while triggering the worklfow. Each subscriber has `avatar` field. For this option to work actor should have `avatar` field set with valid publicly accessible image URL. If the actor doesn't have `avatar` field, then the default avatar will be shown. Worklfow trigger example with avatar

```javascript theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: 'subscriberId_1',
  },
  payload: {
    "key": "value"
  },
  actor: "subscriberId_2"
});
```

Here subscriberId\_2 is used as actor and workflow is triggered to subscriberId\_1

### Static Avatar Url

This option can be used if you want to show same, static and custom avatar icon for each in-app notification of this workflow in-app step. Make sure to toggle off **User Avatar** option to enable this. This is a input field where only valid publicly accessible image URL can be entered. Currently variables are not supported in this field.

### System Avatar Icons

Novu supports 6 system avatar icons. These are default icons that can be selected as avatar icon. Once selected, same icon will be used as avatar icons for all notifications of this in-app step.

## Realtime sockets

Novu provides a real-time socket API for you to consume and get updates about new notifications added to the user's feed. To use the socket connection you can use the `useSocket` hook provided by the `@novu/notification-center` library. Let's see an example of that:

```tsx theme={null}
import { NovuProvider, useSocket } from "@novu/notification-center";

function Novu() {
  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <CustomNotificationCenter />
    </NovuProvider>
  );
}

function CustomNotificationCenter() {
  const { socket } = useSocket();

  useEffect(() => {
    if (socket) {
      socket.on("notification_received", (data) => {
        console.log(data);
      });
    }

    return () => {
      if (socket) {
        socket.off("notification_received");
      }
    };
  }, [socket]);

  return <></>;
}
```

There are three sockets events available:

1. `unseen_count_changed`
2. `unread_count_changed`
3. `notification_received`

### Toast notification

Novu does not have a native toast component. However, if your project is using any UI library like chakra, material-ui, mantine then toast component (snackbar in case of material-ui) of these libraries can be used with `useSocket` hook. Add the toast opening code in `socket.on` callback.

```javascript toast.tsx theme={null}
socket.on("notification_received", (data) => {
  console.log(data);
  // set received notification content as toast content
  setToastContent(data.content)
  // open the toast
  openToast(true)
});
```

## Example

[![Edit kind-nova-xv6s9g](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark)

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="The notification center is not loading properly.">
    Possible reasons for the notification center not loading properly:

    * Invalid subscriberId
    * Invalid applicationIdentifier
    * Invalid subscriberHash (in case of active HMAC encryption)
    * Invalid backendUrl (in case of self-hosted)
    * Invalid socketUrl (in case of self-hosted)
  </Accordion>

  <Accordion title="There is a render error due to the notification center in React.">
    The notification center should be wrapped in `<NovuProvider>`
  </Accordion>

  <Accordion title="What is the difference between a redirect URL and CTA?">
    The redirect URL is for the entire notification item, When the user clicks the notification, the user will be routed to that url. CTA are two call-to-action buttons. `onNotificationClick` function prop is used for redirecting url and the `onActionClick` function prop is used for CTA.
  </Accordion>

  <Accordion title="Can bell icon in Novu dashboard be used for in-app channel testing?">
    Bell icon and notification center in Novu dashboard is only for receiving system related notifications like user you invited has joined, password reset request sent. It can not to used to test notification center. Consider using our [codesandbox example](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark) instead.
  </Accordion>

  <Accordion title="How to fix CORS error with notification center?">
    Our notification center is configures for all hosts. Please disable root level `withCredentials` config in axios or fetch http requests.
  </Accordion>
</AccordionGroup>


# Configuring Multiple Tabs
Source: https://v0.x-docs.novu.co/notification-center/client/react/multiple-tabs



Novu allows to create a multi-tab experience for a notification center, in a way you can fetch the notifications feed using a filtered query.

### Defining stores

To create multiple stores you can use the prop `stores` on the `NovuProvider` component. Each store has `storeId` property that will be used to interact with information related to this store.

```tsx theme={null}
<NovuProvider
  stores={[
    /**
	storeId and feedIdentifier must be identical and should be copied from In-App editor feed
  */
    {
      storeId: "product-updates",
      query: { feedIdentifier: "product-updates" },
    },
    { storeId: "user-activity", query: { feedIdentifier: "user-activity" } },
  ]}
  subscriberId={"SUBSCRIBER_ID"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
>
  <PopoverWrapper />
</NovuProvider>
```

Using the `query` object multiple fields can be passed for feed API:

* `feedIdentifier` - Can be configured and created on the WEB UI
* `seen` - Identifies if the notification has been seen or not

After specifying the `stores` prop, you can use the `storeId` property to interact with the store.

### Managing feeds on the web UI

1. How to add a new feed or select existing feed for In-App step?

To add a new feed, enable *Use Feeds* checkbox in In-App editor. Select from existing feeds or create a new feed by writing in the input field and then clicking on plus icon in the right side.

<Frame>
  <img />
</Frame>

2. How to copy `feedIdentifier` (`storeId`)

To copy `feedIdentifier` (`storeId`) click on the feed name of existing feeds. copy three dot icon. a menu will appear. click on Copy ID option to copy selected feed's `feedIdentifier`

<Frame>
  <img />
</Frame>

<Info>
  By specifying only a storeId, without a query, you could get all notifications.
</Info>

### Using `tabs` prop on the notification center

```tsx theme={null}
<PopoverNotificationCenter
  colorScheme="dark"
  tabs={[
    // name can be any custom name
    { name: "Product Updates", storeId: "product-updates" },
    { name: "User Activity", storeId: "user-activity" },
  ]}
  colorScheme={colorScheme}
  onNotificationClick={handlerOnNotificationClick}
  onActionClick={handlerOnActionClick}
>
  {({ unseenCount }) => {
    return (
      <NotificationBell colorScheme={colorScheme} unseenCount={unseenCount} />
    );
  }}
</PopoverNotificationCenter>
```

<Frame>
  <img />
</Frame>

## Example

[![Edit tabs-in-in\_app](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/tabs-in-in-app-xdk74x?fontsize=14\&hidenavigation=1\&theme=dark)

## Important Links

<CardGroup>
  <Card title="Get all feeds" icon="plug" href="/api-reference/feeds/get-feeds" />

  <Card title="Create a new feed" icon="plug" href="/api-reference/feeds/create-feed" />

  <Card title="Delete a feed" icon="plug" href="/api-reference/feeds/delete-feed" />
</CardGroup>


# Subscriber Preference
Source: https://v0.x-docs.novu.co/notification-center/client/react/preference



By default, Novu will show the subscriber preferences cog icon on the notification center component. If you want to hide it, you can use the prop `showUserPreferences` on the `PopoverNotificationCenter` component.

Users can enable/disable any active channel in the workflow using subscriber preferences

<img />

## Get subscriber preferences

<CodeGroup>
  ```typescript Node.JS theme={null}
  import { Novu } from "@novu/node";

  const novu = new Novu("<NOVU_API_KEY>");

  // 111 is subscriberId
  await novu.subscribers.getPreference("111");
  ```
</CodeGroup>

## Update subscriber preference for a workflow

<CodeGroup>
  ```typescript Node.JS theme={null}
  import { Novu, ChannelTypeEnum } from "@novu/node";

  const novu = new Novu("<NOVU_API_KEY>");

  // enable in_app channel
  await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
    enabled: true,
    channel: { type: ChannelTypeEnum.IN_APP, enabled: true },
  });

  // enable email channel
  await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
    enabled: true,
    channel: { type: ChannelTypeEnum.EMAIL, enabled: true },
  });
  ```
</CodeGroup>

Read more about [subscriber preference](/subscribers/preferences).


# Vue Component
Source: https://v0.x-docs.novu.co/notification-center/client/vue



The `@novu/notification-center-vue` package provides a Vue component wrapper over the Notification Center Web Component that you can use to integrate the notification center into your Vue application.

## Installation

```bash theme={null}
npm install @novu/notification-center-vue
```

<Info>Novu supports only Vue 3.</Info>

## The plugin

The Notification Center Vue plugin can be used to register the `NotificationCenterComponent` as a global component. This is the recommended way to use the component.

```typescript theme={null}
import { createApp } from "vue";
import NotificationCenterPlugin from "@novu/notification-center-vue";
import "@novu/notification-center-vue/dist/style.css";
// your app component
import App from "./App.vue";

createApp(App).use(NotificationCenterPlugin).mount("#app");
```

## Example usage

```html theme={null}
<script lang="ts">
  export default {
    data() {
      return {
        applicationIdentifier: import.meta.env.VITE_NOVU_APPLICATION_IDENTIFIER,
        subscriberId: import.meta.env.VITE_NOVU_SUBSCRIBER_ID,
      };
    },
    methods: {
      sessionLoaded() {
        console.log("Notification Center Session Loaded!");
      },
    },
  };
</script>

<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
  />
</template>
```

By default, the `NotificationCenterComponent` renders the default bell button that opens the notification center when clicked, but it can be customized.

## Custom Bell Button

You can pass the custom bell button component as the default slot to the `NotificationCenterComponent` and it will be used to open the notification center. The `NotificationCenterComponent` also accepts a scoped slot which exposes the `unseenCount` property - the number of unseen notifications counts.

```tsx theme={null}
<script lang="ts">
  export default {
    data() {
      return {
        applicationIdentifier: import.meta.env.VITE_NOVU_APPLICATION_IDENTIFIER,
        subscriberId: import.meta.env.VITE_NOVU_SUBSCRIBER_ID,
      };
    },
    methods: {
      sessionLoaded() {
        console.log('Notification Center Session Loaded!');
      },
    },
  };
</script>

<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>
```

## Example

* [Vue Notification Center Example](https://github.com/novuhq/examples/tree/main/vue-notification-center-example)
* [CodeSandBox Link 🔗](https://codesandbox.io/p/sandbox/novu-vue-in-app-88p8vx)

## Props

The `NotificationCenterComponent` accepts the same set of props as the [Web Component](./web-component#properties).

It also accepts an extra prop

| Prop     | Type      | Description                                                                                                                                          |
| -------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| triggers | string\[] | This is an Array of events that controls the underlying popper component's trigger. [Read more here](https://floating-vue.starpad.dev/api/#triggers) |


# Web Component
Source: https://v0.x-docs.novu.co/notification-center/client/web-component



The Notification Center Web Component is a custom element that can be used in any web application. It is built by wrapping the React components and consists from its core the three pieces:  `NovuProvider`,  `PopoverNotificationCenter`, and  `NotificationBell` combined together into one.

## ESM module[](https://docs.novu.co/notification-center/web-component#esm-module)

Make sure that you have installed the `@novu/notification-center` package:

```bash theme={null}
npm install @novu/notification-center
```

Then, import the web component and register it as a custom element:

```tsx theme={null}
import { NotificationCenterWebComponent } from "@novu/notification-center";

customElements.define(
  "notification-center-component",
  NotificationCenterWebComponent
);
```

After that, you can use the web component in your HTML:

```html theme={null}
<!-- HTML -->
<notification-center-component
  style="display: inline-flex"
  application-identifier="APPLICATION_IDENTIFIER"
  subscriber-id="SUBSCRIBER_ID"
></notification-center-component>
<script>
  // here you can attach any callbacks, interact with the Notification Center Web Component API
  let nc = document.getElementsByTagName("notification-center-component")[0];
  nc.onLoad = () => console.log("Notification Center session loaded!");
</script>
```

**Please note:** that the properties are named with a `kebab-case` in the HTML, but depending on the technology you use it might be a `camelCase`, for ex. Vue/Angular props are bound with variables using that convention.

### Example

[CodeSandBox Link 🔗](https://codesandbox.io/s/novu-web-component-esm-rltcr5)

## Bundled version (preview)

Sometimes you might not be able to use the ESM module, for example in the WordPress environment. In that case, you can use the bundled version of the Notification Center Web Component that is available on the CDN.

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    ...
    <script src="​https://web-component.novu.co/index.js"></script>
  </head>
  <body>
    <notification-center-component
      style="display: inline-flex"
      application-identifier="APPLICATION_IDENTIFIER"
      subscriber-id="SUBSCRIBER_ID"
    ></notification-center-component>
    <script>
      // here you can attach any callbacks, interact with the web component API
      let nc = document.getElementsByTagName(
        "notification-center-component"
      )[0];
      nc.onLoad = () => console.log("hello world!");
    </script>
  </body>
</html>
```

### Example

[CodeSandBox Link 🔗](https://codesandbox.io/s/novu-web-component-bundled-rgrj5r?file=/index.html)

## Properties

The Notification Center Web Component has a few properties that you can use to customize the behavior of the component. The only required property is `applicationIdentifier`.

If you are using TypeScript, then you might want to check the `NotificationCenterComponentProps` interface.

| Prop                       | Type                                                                                         | Description                                                                                                                                                                                                                                                                                                  |
| -------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| backendUrl                 | string                                                                                       | Custom API location in case of self-hosted version of Novu.                                                                                                                                                                                                                                                  |
| socketUrl                  | string                                                                                       | Custom WebSocket Service location in case of self-hosted version of Novu.                                                                                                                                                                                                                                    |
| subscriberId               | string                                                                                       | The subscriberId is a custom identifier used when identifying your users within the Novu platform.                                                                                                                                                                                                           |
| applicationIdentifier      | string                                                                                       | Is a public identifier used to identify your application, can be found in the Novu Admin panel.                                                                                                                                                                                                              |
| subscriberHash             | string                                                                                       | The hashed subscriber id. [Read more about hmac encryption](/notification-center/client/react/get-started#hmac-encryption).                                                                                                                                                                                  |
| stores                     | object\[]                                                                                    | The array of the store items that are bound with the feed, it's used together with tabs property if you would like to have separate feeds in the notification center. [Read more here](/notification-center/client/react/multiple-tabs)                                                                      |
|                            |                                                                                              |                                                                                                                                                                                                                                                                                                              |
| tabs                       | object\[]                                                                                    | The array of items that do describe the tabs/feeds, they are bound with the stores property. [Read more here](/notification-center/client/react/multiple-tabs).                                                                                                                                              |
| showUserPreferences        | boolean                                                                                      | The flag indicating whether the user preference settings should be visible or not.                                                                                                                                                                                                                           |
| allowedNotificationActions | boolean                                                                                      | The flag indicating whether to show/hide the dots menu for actions performed on a notification.                                                                                                                                                                                                              |
| popoverConfig              | object                                                                                       | The object defining how the popover should be positioned. It's properties are position and offset.                                                                                                                                                                                                           |
| popover                    | object                                                                                       | The object defining how the popover should be positioned. It's properties are position and offset. popover is deprecated, use popoverConfig instead.                                                                                                                                                         |
| theme                      | [INovuTheme](/notification-center/client/react/api-reference#the-theme-interface)            | The object defining the the light/dark styles of the Notification Center component. We discourage you to use this prop to do the styling, instead it's recommended to use the styles property.                                                                                                               |
| styles                     | [NotificationCenterStyles](/notification-center/client/react/api-reference#styles-interface) | The object allows you to define the custom CSS code.                                                                                                                                                                                                                                                         |
| colorScheme                | string                                                                                       | The prop defines which color version of the styles the component should set. The options are light and dark.                                                                                                                                                                                                 |
| i18n                       | object                                                                                       | The object allowing to [customize the UI language](/notification-center/client/react/customization#customize-the-ui-language).                                                                                                                                                                               |
| onLoad                     | function                                                                                     | The callback function that is called when the session is successfully initiated. It receives the first argument object with the organization property. There is a sibling property sessionLoaded that might be used in environments that do not allow to use properties with the prefix on, like in Angular. |
| onNotificationClick        | function                                                                                     | The callback function that is called when the user has clicked on the notification. The first argument it receives is the notification object. There is a sibling property notificationClicked.                                                                                                              |
| onUnseenCountChanged       | function                                                                                     | The callback function that is called when the unseen notifications count changes. The first argument it receives is the number of unseen notifications count. There is a sibling property unseenCountChanged.                                                                                                |
| onActionClick              | function                                                                                     | The callback function that is called when user clicks on one of the notification buttons (primary/secondary). The arguments it receives are: template identifier, button type, and notification object. There is a sibling property actionClicked.                                                           |
| onTabClick                 | function                                                                                     | The callback function that is called when user clicks on the feed tab. The first arguments it receives is the tab object. There is a sibling property tabClicked.                                                                                                                                            |

## Limitations

It's important to note that there are some limitations when using the Web Component compared to the React version:

* You get an all-in-one component
* It doesn't support the `children, header, footer, emptyState, listItem` props
* It's a wrapped react component, which means a bigger bundle size (we are working on it to make it smaller)


# Introduction to Notification Center
Source: https://v0.x-docs.novu.co/notification-center/introduction

Learn more about Novu's Notification Center.

The notification center is a component, also sometimes referred to as a widget that furnishes your web application with a beautiful and smooth In-App notification experience for users.

In-App notifications are different from push notifications in the sense that In-App notifications are consumed by the user in your app itself, whether push notifications are shown on the device level. Read more about [push channel and supported providers.](/channels-and-providers/push/overview)

Novu provides a pre-built, ready-to-use, and customizable UI component. It also allows you to bring your own UI via a headless component which can be used to add In-App notifications to any platform.

<iframe />

## Example

[![Edit kind-nova-xv6s9g](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark)

## Why use the Novu notification center?

* Users can manage subscriber preferences from the notification center itself.
* You want to notify about any product activity related to the user.
* Prebuilt UI component so no need to build UI from scratch.
* Highly customizable as per your product design system.
* Multi-device real-time notification experience powered by web sockets.
* Secure your connection using HMAC encryption.
* Have multi-tabs notification experience.

## Concepts

1. `In-App notification`:- In-App notification is a message sent to the subscriber using an In-App channel step in the workflow.
2. `In-App notifications feed`:- List of all In-App messages sent to a particular subscriber.
3. `feeds`:- feeds are stores/tabs in which In-App messages can be grouped. One message can be in only one feed.
4. `notification actions`:- Notification actions are cta buttons below notification content that can be clicked to perform any action or external API call.
5. `redirect url`:- When a single notification item from the list is clicked then it can be configured to perform an action or redirect to any URL.

## UI Libraries

1. [React](/notification-center/client/react/get-started)
2. [Vue](/notification-center/client/vue)
3. [Angular](/notification-center/client/angular)
4. [Web Component](/notification-center/client/web-component)
5. [Headless](/notification-center/client/headless/get-started)

## Backend SDK Methods

[Backend sdk methods](/notification-center/backend/methods)


# Environments
Source: https://v0.x-docs.novu.co/platform/environments

Learn about environments in Novu

Novu runs all your requests in the context of an environment. By default, Novu creates two environments when your account was just created, `development` and `production`.

## Development environment

The development environment is used for testing purposes and validating notification changes prior to committing them to the production environment.

## Production environment

It will be your live/production environment, you cannot make changes to this environment directly. You will first have to make the changes in the `development` environment and then promote it to `production`. This is a read-only environment.

## Data associated with environments

Novu will separate most of the data associated with your account based on the current accessed environment. This will include:

* Subscribers
* Workflows
* Messages
* Execution logs
* Connected integrations
* Notification feeds
* Brand related assets and settings

Each environment will be accessed using a separate credential set:

* **Application Identifier** - This is a public identifier used in client-side applications to identify your application. It is unique to an environment in an organization and is different from `Provider Identifier`.
* **Provider Identifier** - This is an identifier for a provider in a channel. For example, say you're using email notifications. Here, two different providers will have two different `Provider Identifier`. Even if you're using two different integration of the same provider, you'll have two different `Provider Identifier`, each unique to one integration. For example, if you've two slack integrations, they will have two different `Provider Identifier`.
* **API Secret Key** - A secret key used when communicating with the `Novu API` from your backend services.

We suggest configuring these key sets based on your active environment, the same as you would use to manage different service credentials and serve them based on the current environment in which your code is deployed.

## Promoting pending changes to production

After making a change to a workflow or brand relating settings, this change will be added under the [changes](https://web.novu.co/changes?utm_campaign=docs-environments) page in the admin panel.

A change is generated by making a difference between the `development` environment and the target `production` environment. All pending changes will be listed on the [changes](https://web.novu.co/changes?utm_campaign=docs-environments) page.

A change can either be applied manually or by pressing the **Promote all changes** button.

<Frame>
  <img />
</Frame>

<br />

<Note> Before pushing a change to production, make sure that the code associated with this change was pushed to production. This is specifically important when adding new variables to a workflow. </Note>

## API Reference Links

* [Get Current Environment API](/api-reference/environments/get-current-environment/)
* [Get API Keys API](/api-reference/environments/get-api-keys/)
* [Regenerate API Keys API](/api-reference/environments/regenerate-api-keys/)


# Inbound Parse Webhook
Source: https://v0.x-docs.novu.co/platform/inbound-parse-webhook

Learn how to process incoming emails for a domain or subdomain

Inbound Webhook is a feature that allows processing of incoming emails for a domain or subdomain.
The feature parses contents of an email and POSTs the information to a specified URL in a `multipart/form-data` format.

<Note>
  This feature is available only in Novu cloud. This feature will not work in community self
  hosted version and local environment.
</Note>

## Steps to set up Inbound Webhook

1. Set up an MX Record:
   * Log in to your domain host's website and navigate to the MX Records page.
   * Create a new MX record for the subdomain you want to process incoming email (e.g. reply.yourdomain.com).
   <Warning>
     You must create a new record for this as this feature does not work if the MX record is already set on the domain.
     Here is an example with [route 53](https://medium.com/@deep_blue_day/how-to-create-a-subdomain-in-amazon-route-53-81918654f5bf)
   </Warning>
   * Assign the MX record a priority of 10 and point it to the specified inbound mail server that located on the admin dashboard on the Email Settings.
     <Info>
       For US, use `inbound-mail.novu.co` and For EU, use
       `eu.inbound-mail.novu.co`
     </Info>
2. Add Domain to allowed list:
   * Log in to the dashboard.
   * Go to the Setting tab in the left vertical navbar.
   * Navigate to Email Settings on the settings page.
   * Add your domain to the allowed domain box.
   <Warning>
     You can only add one Inbound Webhook domain per organization.
   </Warning>
3. Enable Inbound Parse and Set Webhook URL:
   * Log in to the dashboard.
   * Navigate to the Workflow Editor.
   * Select the email step.
   * Enable the Inbound Parse feature.
   * Set the Webhook URL to the location where you want the parsed data to be POSTed.

<Note>The Webhook URL must be publicly accessible without authentication.</Note>


# Webhooks for Providers
Source: https://v0.x-docs.novu.co/platform/webhooks-for-providers

Learn how to setup webhook support for a provider.

Novu provides a URL that you can use to setup webhook support for your integrated provider.

This enables to receive much more detailed information from the provider about the outgoing messages in the [Activity Feed](/activity-feed/introduction) section.

Currently, only `Email` and `SMS` channels are supported with limited providers. Support for more providers will be added in future.

<Note>
  This feature is available only in Novu cloud. This feature will not work in community self
  hosted version and local environment.
</Note>

## Get your Webhook URL

To get your provider specific webhook URL, follow the below steps:

* Open your already connected provider from the `Integration Store` page.
* Scroll down the modal to find the `Webhook URL` field.
* Copy the given URL to configure it on the provider's webhook setup page.

<Frame>
  <img />
</Frame>

<br />

<Note> Webhook URL will only be visible for connected providers and after you've connected the provider. </Note>

## Supported Providers

* [Mailjet](/channels-and-providers/email/mailjet)
* [Mandrill](/channels-and-providers/email/mandrill)
* [Postmark](/channels-and-providers/email/postmark)
* [Sendgrid](/channels-and-providers/email/sendgrid)
* [Sendinblue](/channels-and-providers/email/sendinblue)
* [Telnyx](/channels-and-providers/sms/telnyx)
* [Twilio](/channels-and-providers/sms/twilio)


# .NET
Source: https://v0.x-docs.novu.co/quickstarts/.NET

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with .NET.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications from a .NET app.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-dotnet) if you don’t have one yet.
* A working .NET development environment with a .NET version of .NET Core 2.0+ and .NET Framework of 4.6.1+.

You can also [view the completed code](https://github.com/novuhq/novu-dotnet-quickstart) of this quick start in a GitHub repo.

## Install Novu .NET SDK

The [.NET SDK](https://github.com/novuhq/novu-dotnet) provides a fluent and expressive interface for interacting with Novu's API and managing notifications.

Now install the Novu .NET SDK by running the following command in your terminal:

```bash theme={null}
dotnet add package Novu

```

Otherwise, modify your .csproj file add the following to it:

```xml theme={null}
<ItemGroup>
    <PackageReference Include="Novu" Version="*" />
</ItemGroup>

```

Next, install the SDK by running the following `dotnet` command:

```bash theme={null}
dotnet restore

```

## Initialize & Configure the Novu SDK

Create a new file, `Program.cs` in your application and add the following code to it:

Program.cs:

```csharp theme={null}
using Novu.DTO;
using Novu.DTO.Topics;
using Novu.Models;
using Novu;

 var novuConfiguration = new NovuClientConfiguration
{
    ApiKey = "<NOVU_API_KEY>",
};

var novu = new NovuClient(novuConfiguration);
```

Replace the `ApiKey`’s value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-dotnet) and be sure to use your specific Novu instance URL.

<Note>
  Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-dotnet) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favourite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create A Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **Untitled.** Rename it to a more suitable title.
4. Select **Email** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

6. Click on the “Test” tab and send a test email to verify your workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. Yaaay, you have successfully sent your first notification via the Novu dashboard! Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click “Subscribers” on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```csharp theme={null}
// Create subscriber

var newSubscriberDto = new SubscriberCreateData
{
  SubscriberId = "77809", //replace with system_internal_user_id
  FirstName = "John",
  LastName = "Doe",
  Email = "benlin1994@gmail.com",
  Data = new List<AdditionalDataDto>{
    new AdditionalDataDto
    {
        Key = "External ID",
        Value = "1122334455"
    },
    new AdditionalDataDto
    {
        Key = "Job Title",
        Value = "Software Engineer"
    }
  }
};

var subscriber = await novu.Subscriber.Create(newSubscriberDto);
```

Run the code in your terminal like so:

```bash theme={null}
dotnet run Program.cs

```

You should see the subscriber on your Novu dashboard.

<Frame>
  <img />
</Frame>

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `UpdateSubscriber` method like so:

Program.cs:

```csharp theme={null}
// Update subscriber detail
var subscriber7789 = await novu.Subscriber.GetSubscriber("7789");

subscriber7789.Email = "validemail@gmail.com"; // replace with valid email
subscriber7789.FirstName = "<insert-firstname>"; // optional
subscriber7789.LastName = "<insert-lastname>"; // optional

var updatedSubscriber = await novu.Subscriber.Update("7789",subscriber7789);
```

Other valid fields that can be updated are `phone`, `avatar`, and `data` . The `data` field can accept an array of metadata that you want to attach to the subscriber.

<Note>
  To make all of your app users subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

OnboardEventPayload.cs:

```csharp theme={null}
// OnboardEventPayload.cs
public class OnboardEventPayload
{
  [JsonProperty("username")]
  public string Username { get; set; }

  [JsonProperty("welcomeMessage")]
  public string WelcomeMessage { get; set; }
}

```

Program.cs:

```csharp theme={null}
var onboardingMessage = new OnboardEventPayload
{
  Username = "jdoe",
  WelcomeMessage = "Welcome to novu-dotnet"
};

var payload = new EventCreateData()
{
  EventName = "onboarding", //make sure you have a trigger named "onboarding"
  To = { SubscriberId = "7789" },
  Payload = onboardingMessage
};

var trigger = await novu.Event.Trigger(payload);

if (trigger.Data.Acknowledged)
{
  Console.WriteLine("Trigger has been created.");
}

```

Before running the code, make sure you understand the following:

* The value of `EventName` should be the workflow’s trigger ID/slug(it's the value all in small caps).

<Frame>
  <img />
</Frame>

* The value of `Payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `SubscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriberId.

Run the code to trigger a notification!

```bash theme={null}
dotnet run Program.cs

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safeguards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```csharp theme={null}
// Create Topic
var topicRequest = new TopicCreateData
{
    Key = "frontend-users",
    Name = "All frontend users",

};

var topic = await novu.Topic.Create(topicRequest);
```

Before running the code, make sure you understand the following:

* When creating a `Key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `Name` should be a descriptive topic name.

## Add Subscribers to a Topic

Copy and paste the following code into your app to add subscribers to a topic:

```csharp theme={null}

// Add Subscriber to Topic
var topicKey = "frontend-users";
var subscriberList = new TopicSubscriberUpdateDto
{
    Keys = new List<string>
    {
        "7789",
        "7790",
    }
};

//Or

var subscriberList = new TopicSubscriberCreateData(new List<string>
{
    "7789",
    "7790"
});

var result = await novu.Topic.AddSubscriber(topicKey, subscriberList);
```

## Sending a Notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

Program.cs

```csharp theme={null}
// Send notifications to a topic (all frontend users)

var onboardingMessage = new OnboardEventPayload
{
  WelcomeMessage = "Welcome to novu-dotnet"
};

var payloadTopic = new EventTopicTriggerDto
{
  EventName = "onboarding",
  Payload = onboardingMessage,
  Topic = { Type = "7789", TopicKey = "frontend-users" },

};

var triggerTopic = await novu.Event.TriggerTopicAsync(payloadTopic);

if (triggerTopic.TriggerResponsePayloadDto.Acknowledged);
{
  Console.WriteLine("Trigger has been created.");
}

```

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider and triggered a notification in your application.


# Angular
Source: https://v0.x-docs.novu.co/quickstarts/angular

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Angular.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications and integrate a rich, customizable and ready-to-use real-time UI In-App notification center in Angular apps.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-angluar) if you don’t have one yet
* Angular CLI (Command Line Interface) installed on your machine
* Angular version 15 or higher

You can also [view the completed code](https://github.com/novuhq/angular-quickstart) of this quick start in a GitHub repo.

## Create a new Angular app

To create a new Angular app, open a terminal or command prompt and  run the following command:

```bash theme={null}
ng new my-app
```

Here, `my-app` is the name of your new Angular app.  This command will create a new Angular app with a basic file structure and all the necessary dependencies installed.

Navigate to the app directory by running the following command:

```bash theme={null}
cd my-app
```

Once you are in the app directory, you can start the development server by running the following command:

```bash theme={null}
ng serve
```

This command will start the development server and launch your app in the default browser. You can access your app by navigating to `http://localhost:4200/`.

<Frame>
  <img />
</Frame>

## Install Novu Angular Notification Center Package

The Novu Angular package provides a Angular component wrapper over the web component that you can use to integrate the notification center into your Angular application.

Navigate to the root directory of your Angular application. Now install the Angular Notification Center package by running the following command in your terminal:

<CodeGroup>
  ```bash pnpm theme={null}
  pnpm i @novu/notification-center-angular
  ```

  ```bash npm theme={null}
  npm i @novu/notification-center-angular
  ```

  ```bash yarn theme={null}
  yarn add @novu/notification-center-angular
  ```
</CodeGroup>

## Configuring Application Environments

Using the Angular CLI, start by running the [generate environments command](https://angular.io/cli/generate#environments-command)
shown here to create the `src/environments/`directory and configure the  project to use these files.

```bash theme={null}
ng generate environments
```

Navigate to `my-app/src/environments/environment.ts`  and add the following variables: `subscriberId`, `applicationIdentifier`

* **`applicationIdentifier`** can be found here: [https://web.novu.co/settings](https://web.novu.co/settings)
* **`subscriberId`** can be found here: [https://web.novu.co/subscribers](https://web.novu.co/subscribers)

```tsx theme={null}
export const environment = {
  production: false,
  subscriberId: '',
  applicationIdentifier: '',
};
```

Copy and paste the same code into `my-app/src/environments/environment.development.ts`

These variables are needed for the `GET` request our notification center will make to Novu’s API to push notifications into the feed.

## Adding Novu Module

Now, navigate to the `app.module.ts` file `(my-app/src/app/app.module.ts)`

* Import `CUSTOM_ELEMENTS_SCHEMA` from `'@angular/core'`
* Add Novu’s notification center module

```jsx theme={null}
import { CUSTOM_ELEMENTS_SCHEMA, NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { AppComponent } from './app.component';
import { NotificationCenterModule } from '@novu/notification-center-angular';

@NgModule({
  declarations: [AppComponent],
  imports: [BrowserModule, NotificationCenterModule],
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
  providers: [],
  bootstrap: [AppComponent],
})
export class AppModule {}
```

Head to `my-app/src/app/app.component.ts` file.

⚠️ The `app.component.ts` file is a critical part of an Angular application, as it  defines the root component and provides the foundation for the rest of  the app's functionality.

Now, we are going to import the `environment` variables to make them accessible in the `app.component.html` and the `styles` properties of our notification center

(there are many properties, but you can discover them later on)

```tsx theme={null}
import { Component } from '@angular/core';
import { environment } from '../environments/environment';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css'],
})
export class AppComponent {
  title = 'my-app';

  subscriberId = environment.subscriberId;
  applicationIdentifier = environment.applicationIdentifier;

  styles = {
    bellButton: {
      root: {
        svg: {
          color: 'white',
          width: '45px',
          height: '40px',
          fill: 'white',
        },
      },
      dot: {
        rect: {
          fill: 'rgb(221, 0, 49)',
          strokeWidth: '0.2',
          stroke: 'white',
          width: '3.5px',
          height: '3.5px',
        },
        left: '40%',
      },
    },
    header: {
      root: {
        backgroundColor: '',
        '&:hover': { backgroundColor: '' },
        '.some_class': { color: '' },
      },
    },
    layout: {
      root: {
        backgroundColor: '',
      },
    },
    popover: {
      arrow: {
        backgroundColor: '',
        border: '',
      },
    },
  };

  sessionLoaded = (data: unknown) => {
    console.log('loaded', { data });
  };
}
```

The Angular component is generated as a wrapper around the original React component. This approach is clever, as it allows Novu's engineers to focus on creating and developing things in the React way.

Additionally, many other frameworks can still use the created components using the wrapping approach.

Now head to the `my-app/tsconfig.json` file, we’re going to add `"allowSyntheticDefaultImports": true` to the `compilerOptions` array.

```diff theme={null}
{
  "compilerOptions": {
+   "allowSyntheticDefaultImports": true,
  }
}
```

## Use & Display The Notification Center Component

Open the `my-app/src/app/app.component.html` file.

This file contain the CSS code along with the HTML one - ideally you should separate the CSS to the `my-app/src/app/app.component.css` file, but it’s not mandatory.

We will add our notification center to the .toolbar div.

Paste the following into your `app.component.html` file:

```jsx theme={null}
  <div id="bell-icon">
    <notification-center-component
      [subscriberId]="subscriberId"
      [applicationIdentifier]="applicationIdentifier"
      [sessionLoaded]="sessionLoaded"
      [styles]="styles"
    ></notification-center-component>
  </div>
```

And in the `<style>` tag, we also want to add some margin to our `#bell-icon` so that it looks good next to the other icons.

```css theme={null}
.toolbar #bell-icon {
  height: '';
  margin: 0 16px;
}
```

Run your app again. Now you should see the bell icon (the notification center) in the toolbar section of your app.

You should now see a **bell button** that opens the notification center when clicked. This bell can be customized to your preference.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Note: There are no notifications because none has been triggered yet. When notifications are sent to a subscriber, it will show up in the UI. Next, we'll learn how to trigger notifications.

* [Angular Notification Center Example Repo](https://github.com/novuhq/examples/tree/main/novu-angular-notification-center)

## Create A Workflow

The first step to trigger notifications is to create a workflow. A workflow is like a map that holds the entire flow of messages sent to the subscriber.

The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **“Create Workflow”** button on the top right.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select **"In-App"** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added In-App channel and configure it according to your preferences. Once you’re done, click Update to save your configuration.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).

Feel free to add only text for now and rename the workflow to `Onboarding In App`. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Next, we’ll learn how to create subscribers on Novu - *Recipients of Notifications*

## Create A Subscriber

Click **Subscribers** on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-angluar) to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu.

Novu has a plethora of backend SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin) to choose from to create a subscriber programmatically. This is the recommended method.

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.identify('123', {
  firstName: 'Emil',
  lastName: 'Pearce',
  returnUser: true,
});
```

Obtain your API key from your [Novu dashboard.](https://web.novu.co/settings?utm_campaign=docs-quick-angluar) Replace `<NOVU_API_KEY>` with it.

Now check your Novu dashboard. You should see the recently created subscriber.

You can also update the subscriber info like so:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('123', {
  firstName: 'Emil', // new first name
  lastName: 'Pearce', // new last name
});
```

## Trigger A Notification

To trigger a notification, simply run the code below with the correct credentials.

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.trigger('onboarding-in-app', {
  to: {
    subscriberId: '132',
  },
});
```

`onboarding-in-app` is the workflow identifier we created earlier.

Ensure the `subscriberId` value in the backend code that triggers the notification matches the `subscriberId` in your `my-app/src/environments/environment.ts` code.

```jsx theme={null}
export const environment = {
  production: false,
  subscriberId: '',
  applicationIdentifier: '',
};
```

Check your app again. You should see the recently triggered notification!

## Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, configured a channel provider and triggered a notification in your Angular application.


# General
Source: https://v0.x-docs.novu.co/quickstarts/general

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications.

To create your free managed, or docker-based Novu environment use our CLI tool:

```
npx novu init
```

After creating your cloud or self-hosted account, the next steps to sending your first notification are outlined in this guide:

* Connect your providers
* Create a workflow
* Send a trigger
* Integrate the [Notification Center](https://docs.novu.co/notification-center/getting-started) within your app *(optional)*

# Connect providers

On the **Integration Store** page, you can configure the different providers and their respective credentials. During the alpha phase only a **single provider** is allowed **per channel**, adding a second email provider will de-activate the previously added email provider.

# Create a workflow

After configuring the designated channel provider, you can create your workflow. You can think of the workflow as the blueprint for the notifications that will be sent. The workflow includes:

* Workflow details
* Channel specific content
* Trigger definition

### Workflow Details

The **name** of the workflow is converted to a slug that is used as the trigger identifier which is used when sending the trigger from the back-end.

### Channel specific content

### Email

You can specify the content for emails in two ways:

**Visual workflow builder** - For simple use cases, you can use our visual workflow editor. The visual workflow builder has limited control over design but is easier to get-started with.

**Custom Code** - You can use the custom code section to specify custom html for the email.

You can specify custom variables using the [handlebars](https://handlebarsjs.com/guide/) syntax.

### SMS

Inside SMS, you can specify custom variables using [handlebars](https://handlebarsjs.com/guide/) syntax.

### In-app

In the notification center preview, you can type the content of the notification, select the content, and use `CMD` + `B` to make the selected text bold.

### Chat

You can specify custom variables using the [handlebars](https://handlebarsjs.com/guide/) syntax.

In addition to the integration, any subscriber needs to set credentials to have proper authorization on the channel.

The credentials can be saved through our `@novu/node` package.

# Trigger the workflow

After creating the workflow, Novu generates the trigger. Use the server SDK in your application in the appropriate place for the specific trigger.

```tsx theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<USER_IDENTIFIER>',
    email: 'email@email.com',
    firstName: 'John',
    lastName: 'Doe',
  },
  payload: {
    customVariables: 'Hello',
  },
});
```

The trigger function contains a parameters object as the second parameter. Let's explore its different options:

### `to` key

The `to` parameter contains the information about the subscriber of the notification. You can work with Novu in 2 modes:

### Pass the subscriber information in the trigger (Quickest)

You can pass the subscriber object containing the following keys as this parameter:

```tsx theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
    firstName,
    lastName,
    email,
    phone,
    avatar,
    locale,
  },
  payload: {},
});
```

The `subscriberId` is a custom identifier that identifies users within the Novu platform. We suggest using your internal DB identifier for this field.

When the trigger is called, Novu performs an upsert command, which either creates a subscriber with the specified payload, or updates the existing subscriber with the passed information.

**Note:** The API performs a PATCH command, updating only the fields passed to it. So to reset a specific field, you must explicitly pass `null` as the fields param.

### Pass only the `subscriberId` (Recommended)

```tsx theme={null}
{
  to: 'SUBSCRIBER_ID',
  payload: {}
}
```

In this approach, you only pass the `subscriberId` as part of the trigger, however, this approach requires you to identify the subscriber using the `identify` method from the `@novu/node`library.

### `payload` object

The `payload` object can pass any serializable JSON object to be used in the workflows.


# Go quickstart
Source: https://v0.x-docs.novu.co/quickstarts/go

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Go.

## Go Quickstart

Welcome to Go Quickstart guide for Novu. In this guide, you'll learn how to use Novu in a Go application. Novu is a powerful notification service that enables you to send multi-channel (SMS, Email, Chat, Push) notifications. Let's see how you can seamlessly integrate Novu into your Go project!

## Prerequisites

Before diving into the Quickstart, make sure you have the following:

* The [Go SDK](https://go.dev/doc/install) installed on your development machine.
* A Novu account. If you don't have one, sign up for free [here](https://web.novu.co?utm_campaign=docs-gs-quick-go)

## Install and Set Up Novu in your Go Project

First, you must install the Novu package in your Go project. From your terminal, you can install the Novu package in your project by running the following command:

```bash theme={null}
go get github.com/novuhq/go-novu

```

Once installed, you can import Novu into your project and initialize it using your Novu account credentials. This step establishes a connection between your app and the Novu notification service.

```go theme={null}
import (
 novu "github.com/novuhq/go-novu/lib"
)

novuClient := novu.NewAPIClient("<NOVU_API_KEY>", &novu.Config{})

```

Replace `<NOVU_API_KEY>` with your own API key that you got from the API Key section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-go).

<Note>
  🔑 Note: Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

## Configure retry

```go theme={null}
import (
 novu "github.com/novuhq/go-novu/lib"
)

novuClient := novu.NewAPIClient(apiKey, &novu.Config{RetryConfig: &novu.RetryConfigType{RetryMax: 3, WaitMin: 1 * time.Second, WaitMax: 5 * time.Second, InitialDelay: 0 * time.Second}})

```

| Options      | Detail                                                          | Default Value |
| ------------ | --------------------------------------------------------------- | ------------- |
| RetryMax     | Specifies total number of retries to perform in case of failure | 0             |
| WaitMin      | Specifies the minimum time to wait before retrying              | 0             |
| WaitMax      | Specifies the maximum time to wait before retrying              | 0             |
| InitialDelay | Specifies the initial delay before the first retry attempt      | 0             |

<Info>
  Above retry configuration is applied to all the sdk methods.
</Info>

## Set Up A Channel Provider

A channel provider is a service that lets you use one or more notification channels such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-go) currently supports four channels: Email, SMS, Chat, and Push. Each of these channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel** at a time. Connect anyone of your preferred providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Notification Workflow

A notification workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber.

The workflow includes the following:

* Notification workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be setup for the Chat channel.
</Note>

To create a notification workflow, please follow the following steps:

1. Click **Workflows** on the left sidebar of your Novu dashboard.

2. Click the **Create Workflow** button on the top right.

3. Select **blank workflow** from the dropdown.

4. The name of a new workflow is currently "Untitled." Rename it to a suitable title.

5. Select any channel you want to use in your app. For the sake of this guide, we'll be using the 'Email' channel.
   <Frame>
     <img />
   </Frame>

6. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

7. Click on the “Test” tab and send a test email to verify your notification workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. If you didn't, please check your 'spam' folder as sometimes test emails can end up there. Yaaay, you have successfully sent your first notification via the Novu dashboard!

Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display only one subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)


## Create a subscriber
func main() {
    ctx := context.Background()
    subscriberID := "<REPLACE_WITH_YOUR_SUBSCRIBER>"
    subscriber := novu.SubscriberPayload{
     LastName: "Skjæveland",
     Email:    "benedicte.skjaeveland@example.com",
     Avatar:   "https://randomuser.me/api/portraits/thumb/women/79.jpg",
     Data: map[string]interface{}{
      "location": map[string]interface{}{
       "city":     "Ballangen",
       "state":    "Aust-Agder",
       "country":  "Norway",
       "postcode": "7481",
      },
     },
    }

 resp, err := novuClient.SubscriberApi.Identify(ctx, subscriberID, subscriber)
 if err != nil {
  log.Fatal("Subscriber error: ", err.Error())
  return
 }

 fmt.Println(resp)
}

```

Run the code in your terminal like so:

```bash theme={null}
go run main.go # replace main.go with your file name

```

You should see a new subscriber (that you created above) on your Novu dashboard.

## Update A Subscriber

To update the Subscriber details you can call the put method from SubcriberApi. Here is an example:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Update subscriber details
func main() {
    ctx := context.Background()
    subscriberID := "<REPLACE_WITH_YOUR_SUBSCRIBER>"
    updateSubscriber := novu.SubscriberPayload{FirstName: "Susan"}
 updateResp, err := novuClient.SubscriberApi.Update(ctx, subscriberID, updateSubscriber)
 if err != nil {
  log.Fatal("Update subscriber error: ", err.Error())
  return
 }

 fmt.Println(updateResp)
}

```

<Note>
  Note: To send notifications to all your users, you'll need to make them subscribers in Novu, which you can do by programmatically adding them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Trigger A Notification
func main() {
    subscriberID := "<REPLACE_WITH_YOUR_SUBSCRIBER>"
 apiKey := "<REPLACE_WITH_YOUR_API_KEY>"
 eventId := "<REPLACE_WITH_YOUR_EVENT_ID>"

 ctx := context.Background()
 to := map[string]interface{}{
  "lastName":     "Nwosu",
  "firstName":    "John",
  "subscriberId": subscriberID,
  "email":        "johnnwosu@email.com",
 }
 payload := map[string]interface{}{
  "name": "Hello World",
  "organization": map[string]interface{}{
   "logo": "https://happycorp.com/logo.png",
  },
 }
 
 novuClient := novu.NewAPIClient(apiKey, &novu.Config{})
 triggerResp, err := novuClient.EventApi.Trigger(ctx, eventId, novu.ITriggerPayloadOptions{
  To:      to,
  Payload: payload,
 })
 if err != nil {
  log.Fatal("Novu error", err.Error())
  return
 }

 fmt.Println(triggerResp)
}

```

Before running the code, make sure you understand the following:

* The value of `eventId` should be the notification workflow's trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the notification template content.
* The value of `subscriberId` is the id of the subscriber on Novu.

Replace all items with their respective and accurate values.

Run the code to trigger a notification!

```bash theme={null}
go run main.go # replace main.go with your file name

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Create Topic
func main() {
    ctx := context.Background()
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
    topicName := "<REPLACE_WITH_YOUR_TOPIC_NAME>"
 createResp, err := novuClient.TopicsApi.Create(ctx, topicKey, topicName)
 if err != nil {
  log.Fatal("Create topic error: ", err.Error())
  return
 }

 fmt.Println(createResp)
}

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

## Add subscriber to Topic
func main() {
    ctx := context.Background()
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
    subscribers := []string{"<SUBSCRIBER_ID_1>", "<SUBSCRIBER_ID_2>"}
 addSubscribersResp, err := novuClient.TopicsApi.AddSubscribers(ctx, topicKey, subscribers)
 if err != nil {
  log.Fatal("Add subscriber to topic error: ", err.Error())
  return
 }

 fmt.Println(addSubscribersResp)
}

```

On the other hand, if you want to remove subscribers from a topic, do the following:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

## Remove subscriber from Topic
func main() {
    ctx := context.Background()
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
    subscribers := []string{"<SUBSCRIBER_ID_1>", "<SUBSCRIBER_ID_2>"}
 removeSubscribersResp, err := novuClient.TopicsApi.RemoveSubscribers(ctx, topicKey, subscribers)
 if err != nil {
  log.Fatal("Add subscriber to topic error: ", err.Error())
  return
 }

 fmt.Println(addSubscribersResp)
}

```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Trigger A Notification
func main() {
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
 apiKey := "<REPLACE_WITH_YOUR_API_KEY>"
 eventId := "<REPLACE_WITH_YOUR_EVENT_ID>"
 ctx := context.Background()
 
 to := map[string]interface{}{
  "type":     "Topic",
  "topicKey":    topicKey
 }
 payload := map[string]interface{}{
  "name": "Hello World",
  "organization": map[string]interface{}{
   "logo": "https://happycorp.com/logo.png",
  },
 }
 
 novuClient := novu.NewAPIClient(apiKey, &novu.Config{})
    triggerResp, err := novuClient.EventApi.Trigger(ctx, eventId, novu.ITriggerPayloadOptions{
      To:      to,
      Payload: payload,
     })
 if err != nil {
  log.Fatal("Novu error", err.Error())
  return
 }

 fmt.Println(triggerResp)
}

```

## Next Steps

Great job! If you've reached this point, you should now have successfully created a subscriber, notification workflow, configured a channel provider and triggered a notification in your application.

To learn more about notifications and explore Novu's features and capabilities, check out:

* [Novu Digest Engine](https://docs.novu.co/platform/digest) - Learn how to aggregate multiple trigger events into a single message and deliver it to the subscriber.
* [Novu Go SDK](https://github.com/novuhq/go-novu) - Delve deeper into the SDK and explore a lot of features.
* [Novu Notification Center](/getting-started/introduction) - Learn how to integrate a rich, ready-to-use real-time UI notification center into your app.


# iFrame
Source: https://v0.x-docs.novu.co/quickstarts/iFrame

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with iFrame embed

## Requirements

To follow the steps in this quickstart, you’ll need:

* A Novu account. **[Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-iframe)** if you don’t have one yet.
* Basic knowledge of HTML and JavaScript.

You can also **[view the completed code](https://github.com/novuhq/iframe-quickstart)** of this quick start in a GitHub repo.

## Create a workflow

Before triggering a notification, we need to create a workflow. A workflow is like a blueprint that all the notifications are supposed to follow.

> The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

These are the steps to create a workflow:

1. Click **Workflow** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **“Untitled”**. Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.

<img />

Select the in-app channel.

1. Click on the recently added “In-App” channel and configure it according to your preferences. Once you’re done, click “Update” to save your configuration.

<img />

Configure the in-app node as per your needs.

I’ll briefly explain the function of each label in the image above:

* **1-Preview**: This shows you a glimpse of how each notification item will look in the Notification Center UI.
* **2-Avatar**: If turned on, each notification item will show the avatar of the subscriber.
* **3-Action**: With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds**: This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL**: This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter**: This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber’s online status to send them an email if they were online within the last hour. Read [more about filters](/workflows/notification-workflows).
* **7-Editor**: You can add text that you want to be displayed in each notification item. Additionally, you can specify custom variables using **`{{ }}`**. This means you can inject variables from your code into a notification item’s text via a payload.

In our case, we’ll use the custom variables functionality, as shown below:

<img />

We're gonna use custom variables here.

Feel free to add only text for now and rename the workflow to quickstart. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.
Rename the workflow to 'quickstart'.

<img />

Now, we’ll learn how to create subscribers on Novu - Recipients of Notifications!

## Create a subscriber

If you click “Subscriber” on the left sidebar of the **[Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-iframe)**, you’ll see the subscriber list. By default, there will only be one subscriber as you’re automatically added as a subscriber when you sign up for Novu:

<img />

<Note> One subscriber is automatically created when you sign up. If you don't see the default subscriber, follow [how to create subscriber](/subscribers/subscribers#create-a-subscriber) documentation to learn on how to create one </Note>

Now, let’s create a subscriber on Novu. After creating a subscriber, we’ll trigger a notification to this subscriber. Subscribers are identified by a unique **`subscriberId`**.

With Novu, you can create a subscriber using any of its SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin). The code to create a subscriber in Novu is:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.identify('123', {
  firstName: 'Sumit',
  lastName: 'Saurabh',
});
```

You can get your API key from the Novu dashboard. Replace **`<NOVU_API_KEY>`** with it. Now, if you’ll go to the Novu dashboard, you shall see the subscriber we created above with **`subscriberId`** of **`123`**.

You can also update information about an already existing subscriber using the **`subscriber.update`** method as shown below:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('123', {
  firstName: 'Saurabh', // new first name
  lastName: 'Sumit', // new last name
});
```

## Embed iFrame Notification Center in a your web app

1. Create a simple HTML file, you can call it `index.html`

2. Copy the following code snippet, it contains a basic html structure with some design elements to make things look more pretty

   <Note> Note that we are using fontAwesome library as a stylesheet dependency. </Note>

   ```html theme={null}
   <!DOCTYPE html>
   <html lang="en">

   <head>
       <meta charset="UTF-8">
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css">

       <title>iFrame Quickstart</title>
       <style>
           body {
               font-family: Arial, sans-serif;
               background-color: #f4f4f4;
               margin: 0;
               padding: 0;
               display: flex;
               justify-content: center;
               align-items: top;
               min-height: 100vh;
           }

           .container {
               text-align: center;
               padding: 20px;
               border-radius: 10px;
               background-color: #ffffff;
               box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.1);
           }

           h1 {
               color: #333333;
           }

           p {
               color: #666666;
               line-height: 1.6;
           }

           .fa {
               cursor: pointer;
           }

           .fa:hover {
               color: #0056b3;
           }
       </style>
   </head>

   <body>

       <div class="container">
           <h1>iFrame Notification Center Icon Bell</h1>
           <div id="notification-bell">
               <i class="fa fa-bell fa-2x"></i>
               <span id="unseen-badge"></span>
           </div>
           <p>Click on the notification bell to see the feed</p>
       </div>
       </div>

       <script>
       </script>
   </body>

   </html>
   ```

3. To activate the iFrame, you should include the following code as a script in your html app.

   ```jsx theme={null}
   <script>
     (function(n,o,t,i,f) {
       n[i] = {}; var m = ['init', 'on']; n[i]._c = [];m.forEach(me => n[i][me] = function() {n[i]._c.push([me, arguments])});
       var elt = o.createElement(f); elt.type = "text/javascript"; elt.async = true; elt.src = t;
       var before = o.getElementsByTagName(f)[0]; before.parentNode.insertBefore(elt, before);
     })(window, document, 'https://embed.novu.co/embed.umd.min.js', 'novu', 'script');

     novu.init(
       '<REPLACE_applicationIdentifier>',
       {
         unseenBadgeSelector: '#unseen-badge',
         bellSelector: '#notification-bell',
       },
       {
         subscriberId: '<REPLACE_WITH_subscriberId>',
       }
     );
   </script>
   ```

   You’ll notice two things used above - **`applicationIdentifier`** and **`subscriberID`**.

   An application identifier is a public key used to identify your application. You can get your own application identifier from the **[Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-iframe)**.

   And subscribers are users to which notifications will be sent. They are identified by a **`subscriberID`** which you can also find in the **[Novu subscribers dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-iframe)**.

4. Now open your html application, you should see something like this:

<img />

If you have replaced the `applicationIdentifier` and `subscriberID`, when you will click the bell, you will see the following:

<img />

To learn how to design and modify your iFrame component, feel free to visit the more in-depth [iFrame section](notification-center/client/iframe).

## Trigger a notification

We can trigger a notification by simply clicking on the `Get Snippet` button

<img />

Switch to `Run a Test` option

<img />

Change the `subscriberId` that we have created (`123`)

<img />

Click on `Run Trigger`

<img />

This will take the workflow we created above with the identifier `quickstart` and send a notification to the subscriber with `subscriberId` of `123`.

Now we will open our web application and see a red dot next to the bell icon, this indicate that we have an unseen notification in our feed.

When we will click on it, we will see our notification.

<img />

## Conclusion

Great job! If you’ve reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, triggered a notification and saw it in your web application using iFrame embed.

If you want to learn more about iFrame embed component, please visit [this section](/notification-center/client/iframe) of the documentation.


# Java quickstart
Source: https://v0.x-docs.novu.co/quickstarts/java

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Java.

## Java Quickstart

Learn how to integrate Novu into your Java project on the fly and send notifications across different channels (SMS, Email, Chat, Push).

In this Quickstart, you will learn how to:

* [Install and Set up the Novu Java SDK.](#install-and-set-up-the-novu-java-sdk-in-your-project)
* [Configure a Notification Channel Provider.](#set-up-a-channel-provider)
* [Set up a Notification Workflow.](#create-a-notification-workflow)
* [Create a Subscriber and update a Subscriber's information.](#create-a-subscriber-and-update-a-subscribers-information)
* [Send your first Notification to a Subscriber.](#trigger-a-notification)
* [Send Notifications via Topics.](#topics)

Let's get started! :muscle:

## Requirements

To be able to use this Quickstart, you would need to have the following:

* A Novu account, if you don't have one yet, [sign up](https://web.novu.co?utm_campaign=docs-gs-quick-java) for free.
* A working Java development environment with JDK 17 and Springboot Framework of 3.1.2+.

The completed code for this quick start is available on GitHub. Check it out [here](https://github.com/novuhq/novu-java-quickstart).

## Install and Set up the Novu Java SDK in your project

First, you need to import the library into your application.
If you use Maven, add the dependency to the `pom.xml` file;

```xml theme={null}
<dependency>
  <groupId>co.novu</groupId>
  <artifactId>novu-java</artifactId>
  <version>{use-latest-version}</version>
</dependency>
```

The latest version can be found [on GitHub.](https://github.com/novuhq/novu-java#installation)

If you use Gradle, add the dependency to the `build.gradle` file;

```groovy theme={null}
dependencies {
  implementation 'co.novu:novu-java:{use-latest-version}'
}
```

Sync your project, and you should have the artifacts downloaded.

To use the SDK, you need to have your API key handy, it can be gotten from [settings page](https://web.novu.co/settings?utm_campaign=docs-quick-java) of the web dashboard.

To initialize the library, you can create an instance of `Novu.java` class using any of the following constructors:

```java theme={null}
//Using the API Key only
String apiKey = "INSERT_API_KEY_HERE";
  Novu novu = new Novu(apiKey);
```

```java theme={null}
//Using the API Key plus an instance of NovuConfig
String apiKey = "INSERT_API_KEY_HERE";
  NovuConfig novuConfig = new NovuConfig(apiKey);
  Novu novu = new Novu(novuConfig);
```

Once that is done successfully, head over to the [web dashboard](https://web.novu.co?utm_campaign=docs-quick-java) for the next steps.

## Set up a Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification, etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-java) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favorite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Notification Workflow

A notification workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Notification workflow name and Identifier.
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a notification workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.

<Frame>
  <img />
</Frame>

3. The name of a new notification workflow is currently **Untitled**, rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select **Email** as the channel you want to add, by dragging it from the right sidebar.

<Frame>
  <img />
</Frame>

5. Click on the **Email** in the workflow and edit it as per this image. Don't forget to add the fields in the editor which is supposed to be updated with dynamic values that will be sent when calling the API.
   <Frame>
     <img />
   </Frame>

6. Also, add the variables in the **Variables** section in the test tab and try testing it by sending the email to your email address using the **Send Test Email** button at the bottom right.
   <Frame>
     <img />
   </Frame>

You should get an email within seconds! :ok\_hand:

Great, you have successfully sent your first notification via the Novu dashboard! Now, let's take a step further to trigger notifications via code.

## Create and Update a Subscriber's Information

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);

    SubscriberRequest subscriberRequest = new SubscriberRequest();
        subscriberRequest.setEmail("email");
        subscriberRequest.setFirstName("fName");
        subscriberRequest.setLastName("lName");
        subscriberRequest.setPhone("phone");
        subscriberRequest.setAvatar("avatar");
        subscriberRequest.setSubscriberId("subscriberId");
            try {
                return novu.createSubscriber(subscriberRequest);
            }catch (Exception e){
                log.error("Error Creating Subscriber", e);
            }

            return null;
```

When you run this code snippet, you should see the subscriber on your Novu dashboard.

Now, let's assume you want to modify the email address of the subscriber you just created, you can do that with the following code:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);

    UpdateSubscriberRequest updateSubscriberRequest = new UpdateSubscriberRequest();
        updateSubscriberRequest.setEmail("updatedEmail");
        updateSubscriberRequest.setFirstName("fName");
        updateSubscriberRequest.setLastName("lName");
        updateSubscriberRequest.setPhone("phone");
        updateSubscriberRequest.setAvatar("avatar");

        String subscriberId = "subscriberId";

        try {
            return novu.updateSubscriber(updateSubscriberRequest, subscriberId);
        }catch (Exception e){
            log.error("Error updating Subscriber", e);
        }

        return null;
```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an Object or a Map with the info you want to attach to the subscriber.

<Note>
  To create all of your subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger a Notification

Copy and paste the following code into your app to trigger a notification to a Subscriber:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);

    SubscriberRequest subscriberRequest = new SubscriberRequest();
            subscriberRequest.setSubscriberId("subscriberId");
            subscriberRequest.setEmail("email;");
            subscriberRequest.setFirstName("fName");
            subscriberRequest.setLastName("lName");

    TriggerEventRequest triggerEventRequest = new TriggerEventRequest();
            triggerEventRequest.setName("name");
            triggerEventRequest.setTo(subscriberRequest);
            triggerEventRequest.setPayload(Collections.singletonMap("customVariables", "Hello"));


    try {
        return novu.triggerEvent(triggerEventRequest);
    }catch (Exception e){
        log.error("Error triggering event", e);
    }

            return null;
```

Before running the code, make sure you understand the following:

* The value of `payload` is an array of the data that you want to be dynamically injected into the notification workflow content.
* The value of `subscriberId` is the ID of the subscriber on Novu. Replace `12345` with your subscriber ID.

Run the code to trigger a notification!

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops. A topic is identified by a custom key that is provided by the user, and this key will be the identifier used in the Topics API.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also caters for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```java theme={null}
String apiKey = "API_KEY";
Novu novu = new Novu(apiKey);

TopicRequest createTopicRequest = new TopicRequest();
    createTopicRequest.setKey("key");
    createTopicRequest.setName("name");
        try {
            return novu.createTopic(createTopicRequest);
        }catch (Exception e){
            log.error("Error creating Topic", e);
        }

        return null;
```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add Subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```java theme={null}
String apiKey = "API_KEY";
Novu novu = new Novu(apiKey);

        String topicKey = "key";
        SubscriberAdditionRequest requestBody = new SubscriberAdditionRequest();
        requestBody.setSubscribers(Collections.singletonList("aSubscriberId"));

        try {
            return novu.addSubscriberToTopic(requestBody,topicKey);
        }catch (Exception e){
            log.error("Error Adding Subscriber To Topic", e);
        }

        return null;
```

On the other hand, if you want to remove subscribers from a topic, do the following:

```java theme={null}
String apiKey = "API_KEY";
Novu novu = new Novu(apiKey);


        String topicKey = "key";
        SubscriberAdditionRequest requestBody = new SubscriberAdditionRequest();
        requestBody.setSubscribers(Collections.singletonList("aSubscriberId"));

        try {
            return novu.removeSubscriberFromTopic(requestBody, topicKey);
        }catch (Exception e){
            log.error("Error Removing Subscriber From Topic", e);
        }

        return null;
```

## Send a Notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);


    Topic topic = new Topic();
        topic.setType("Topic");
        topic.setTopicKey("topicKey");

    TriggerEventRequest triggerEventRequest = new TriggerEventRequest();
            triggerEventRequest.setName("name");
            triggerEventRequest.setTo(topic);
            triggerEventRequest.setPayload(Collections.singletonMap("customVariables", "Hello"));


    try {
        return novu.triggerEvent(triggerEventRequest);
    }catch (Exception e){
        log.error("Error sending notification to topic", e);
    }

            return null;
```

## Next Steps

Great job! :clap: If you've reached this point, you should have successfully created a subscriber, notification workflow, configured a channel provider, triggered a single notification, created a topic, added a subscriber to a topic in your application.

To learn more about notifications and explore Novu's features and capabilities, check out:

* [Novu Java SDK](https://github.com/novuhq/novu-java) - Dive deeper into the SDK and explore a lot of features.
* [Novu Digest Engine](/guides/add-digest-to-inapp-notifications) - Learn how to aggregate multiple trigger events into a single message and deliver it to the subscriber.
* [Novu Notification Center](/getting-started/introduction) - Learn how to integrate a rich, ready-to-use real-time UI notification center into your app.


# Kotlin quickstart
Source: https://v0.x-docs.novu.co/quickstarts/kotlin

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Kotlin.

Learn how to integrate Novu into your Kotlin project on the fly and send notifications across different channels (SMS, Email, Chat, Push).

Let's get started! 💪

## Requirements

To be able to use this Quickstart, you would need to have the following:

* A Novu account, if you don't have one yet, [sign up](https://web.novu.co/?utm_campaign=docs-gs-quick-kotlin) for free.
* A working Kotlin project running version 1.6.0+ and Kotlin compiler 1.8.0+.

The completed code for this quick start is available on GitHub. Check it out [here](https://github.com/novuhq/novu-kotlin-quickstart).

## Install and Set up the Novu Kotlin SDK in your project

First, you need to import the library into your application.

If you use Maven, add the dependency to the `pom.xml` file;

```xml theme={null}
<dependency>
  <groupId>co.novu</groupId>
  <artifactId>novu-kotlin</artifactId>
  <version>{use-latest-version}</version>
</dependency>
```

The latest version can be found [on GitHub.](https://github.com/novuhq/novu-kotlin#installation)

If you use Gradle, add the dependency to the `build.gradle` file;

```groovy theme={null}
implementation 'co.novu:novu-kotlin:{use-latest-version}' //Groovy

implementation ("co.novu:novu-kotlin:{use-latest-version}") //Kotlin
```

Sync your project, and you should have the artifacts downloaded.

To use the SDK, you need to have your API key handy, it can be gotten from the [settings page](https://web.novu.co/settings?utm_campaign=docs-quick-kotlin) of the web portal.

To initialize the library, you can create an instance of `Novu.kt` class using any of the following constructors:

```kotlin theme={null}
//Using the API Key only
val novu = Novu(apiKey = "API_KEY")

```

```kotlin theme={null}
//Using the API Key plus an instance of NovuConfig
val novuConfig = NovuConfig(backendUrl = "URL")
val novu = Novu(apiKey = "API_KEY", config = novuConfig)

```

Once that is done successfully, head over to the [web portal](https://web.novu.co/?utm_campaign=docs-quick-kotlin) for the next steps.

## Set up a Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification, etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-kotlin) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favourite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier.
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.

<Frame>
  <img />
</Frame>

3. The name of the new workflow is currently Untitled, rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select Email as the channel you want to add, by dragging it from the right sidebar.

<Frame>
  <img />
</Frame>

5. Click on the Email in the workflow and edit it as per this image. Don’t forget to add the fields in the editor which is supposed to be updated with dynamic values that will be sent when calling the API.

<Frame>
  <img />
</Frame>

6. Also, add the variables in the Variables section in the test tab and try testing it by sending the email to your email address using the Send Test Email button at the bottom right.

<Frame>
  <img />
</Frame>

You should get an email within seconds! 👌

Great, you have successfully sent your first notification via the Novu dashboard! Now, let’s take a step further to trigger notifications via code.

## Create a Subscriber and Update a Subscriber's information

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```kotlin theme={null}
suspend fun createSubscriber(): ResponseWrapper<SubscriberResponse>? {
        val novu = Novu(apiKey = "API_KEY")
        val subscriberRequest = SubscriberRequest(
            email = "email@sample.com",
            firstName = "John",//optional
            lastName = "Doe",//optional
            phone = "123456789",//optional
            avatar = "sample-avatar",//optional
            subscriberId = "12345"//optional
        )
        return CoroutineScope(Dispatchers.IO).async {
            novu.createSubscriber(subscriberRequest)
        }.await()
    }

```

When you run this code snippet, you should see the subscriber on your Novu dashboard. 👤

Now, let's assume you want to modify the email address of the Subscriber you just created, you can do that with the following code:

```kotlin theme={null}
suspend fun updateSubscriber(): ResponseWrapper<SubscriberResponse>? {
        val novu = Novu(apiKey = "API_KEY")
        val subscriberRequest = UpdateSubscriberRequest(
            email = "validemail@sample.com",
            firstName = "John",//optional
            lastName = "Doe",//optional
            phone = "123456789",//optional
            avatar = "sample-avatar"//optional
        )
        val subscriberId = "12345"
        return CoroutineScope(Dispatchers.IO).async {
            novu.updateSubscriber(subscriberId, subscriberRequest)
        }.await()
    }

```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an Object or a Map with the info you want to attach to the subscriber.

<Note>
  To create all of your subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger a Notification

Copy and paste the following code into your app to trigger a notification to a Subscriber:

```kotlin theme={null}
suspend fun triggerNotification(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val triggerEventRequest = TriggerEventRequest(
            name = "test",
            to = SubscriberRequest(
                subscriberId = "12345",
                email = "email@email.com",
                firstName = "John",
                lastName = "Doe"
            ),
            payload = mapOf("customVariables" to "Hello")
        )

        return CoroutineScope(Dispatchers.IO).async {
            novu.trigger(triggerEventRequest)
        }.await()
    }

```

Before running the code, make sure you understand the following:

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the ID of the subscriber on Novu. Replace `12345` with your subscriber ID.

Run the code to trigger a notification! 📧

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops. A topic is identified by a custom key that is provided by the user, and this key will be the identifier used in the Topics API.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also caters for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```kotlin theme={null}
suspend fun createTopic(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val createTopicRequest = CreateTopicRequest(
            key = "key",
            name = "name"
        )
        return CoroutineScope(Dispatchers.IO).async {
            novu.createTopic(createTopicRequest)
        }.await()
    }

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```kotlin theme={null}
suspend fun addSubscriberToTopic(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val topicKey = "key"
        val requestBody = SubscriberList(listOf("name"))
        return CoroutineScope(Dispatchers.IO).async {
            novu.addSubscribers(topicKey, requestBody)
        }.await()
    }

```

On the other hand, if you want to remove subscribers from a topic, do the following:

```kotlin theme={null}
suspend fun removeSubscriberFromTopic(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val topicKey = "key"
        val requestBody = SubscriberList(listOf("name"))
        return CoroutineScope(Dispatchers.IO).async {
            novu.removeSubscriber(topicKey, requestBody)
        }.await()
    }

```

## Sending a Notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```kotlin theme={null}
suspend fun triggerNotificationToTopic(): Any? {
        val novu = Novu(apiKey = "NOVU_API_KEY")
        val triggerEventRequest = TriggerEventRequest(
                name = "test",
                to = listOf(
                        Topic(
                                type = "Topic",
                                topicKey = "posts:comment:12345"
                        )
                ),
                payload = mapOf("customVariables" to "Hello")
        )

        return CoroutineScope(Dispatchers.IO).async {
            novu.trigger(triggerEventRequest)
        }.await()
    }
```

## Conclusion

Great job! 👏
If you've reached this point, you should have successfully created a subscriber, workflow, configured a channel provider, triggered a single notification, created a topic, and added a subscriber to a topic in your application.


# NextJS
Source: https://v0.x-docs.novu.co/quickstarts/nextjs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with NextJS.

This quick start guide is written to help you integrate Novu into your NextJS app in no time. Novu is an open-source notifications infrastructure that you can use in your app to deliver rich notifications across channels like sms, email, in-app, push, chat, etc. In this guide, you’ll learn how to integrate email notifications into your NextJS app.

You can find the code for this app [here](https://github.com/novuhq/nextjs-quickstart/)

## Prerequisites

* Node.js installed on your development machine (to create a NextJS app).
* A Novu account. If you don't have one, sign up for free [here](https://web.novu.co/workflows?utm_campaign=docs-quick-nextjs).

## Create a NextJS app to get started

The first step here would be to create a NextJS app. We will play with Novu in this app later. To get started, open your terminal and create a NextJS app using the following command:

```bash theme={null}
npx create-next-app@latest

```

This will create a NextJS app and now we can add Novu to our project. Open the app using a code editor of your choice. The benefit of using NextJS is that it provides native support for routing, making it effortless to handle navigation and create dynamic pages in your application.

Next.js uses a file-based routing system, where each page in your application is represented by a corresponding file in the `pages` directory.

By creating a new file in the `pages` directory, such as `about.js`, we automatically create a route `/about` in our application. Next.js handles the routing logic behind the scenes, ensuring that when a user accesses `/about`, the corresponding page component is rendered.

In our app, we’ll create a route that will send an email notification to a specified email id. To do this, we need two things:

* Install Novu and connect it to our app
* Create the route and define a function in that route

## Installing Novu and connecting it to the app

To install Novu, simply open your terminal and issue the following command:

```bash theme={null}
npm install @novu/node

```

After installing it, we need to connect our app with our Novu account using the Novu API key. Simply log onto the [Novu web dashboard](https://web.novu.co?utm_campaign=docs-quick-nextjs/) and from the settings there, obtain your API key. We’ll use it to connect our app to our Novu account.

<Frame>
  <img />
</Frame>

Now, we need to connect it to our app. To do so, the first step is to import Novu into our app. Importing Novu will give us the ability to interact with the Novu API. To import Novu into our app, use the following code in a separate file in our app:

```jsx theme={null}
import { Novu } from '@novu/node';

// replace <NOVU_API_KEY> with your actual API key
const novu = new Novu(<NOVU_API_KEY>);
```

Novu lets us send notifications across different channels like email, in-app, chat, SMS, etc, and for each channel, one can use a plethora of providers. You just need to set up a provider for the channel you want to use in Novu:

| Channel | Providers                                                           |   |
| ------- | ------------------------------------------------------------------- | - |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |   |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |   |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |   |
| Push    | FCM, APNS, Expo                                                     |   |

You can see all this in our [integrations store](https://web.novu.co/integrations?utm_campaign=docs-quick-nextjs) and set it up there.

For each channel, there can be only one provider active at a time. Although the exact setup process varies from provider to provider, the general flow is signing up for a provider, getting an API key from its portal, and plugging it into the Novu web portal.

Once having integrated a provider, we need a workflow to send notifications. One can have dynamic data in this workflow if they so choose.

In our case, we’ll have dynamic data and whatever we send as a description will be sent as an email notification. Following are the steps to create a workflow.

## Creating a workflow

1. Click "Workflows” on the left sidebar of your Novu dashboard.
2. Click the “Create Workflow” button on the top right.

<Frame>
  <img />
</Frame>

3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select "Email" as the channel you want to add, by dragging it from the right sidebar:

<Frame>
  <img />
</Frame>

5. Click on the ‘Email’ in the workflow and edit it as per this image. Don’t forget to add the fields in the editor which is supposed to be updated with dynamic values that we’ll send when calling the API.

<Frame>
  <img />
</Frame>

6. Also, add the variables in the ‘variables’ section in the test tab and try testing it by sending the email to your email id using the ‘send test email’ button on the bottom right.

<Frame>
  <img />
</Frame>

Now, we’ve successfully sent the test email and just need to do this from our app.

## Subscribers

In Novu, entities that are supposed to receive notifications are called subscribers. You can see all the subscribers in the ‘subscribers’ tab in the left menu on the Novu web portal. There would be one subscriber by default, which is you. This was created when you signed up for Novu.

In real-world scenarios, the `subscriber id` would be a unique id generated automatically by the database. So for our demo purpose, we’re using a simple subscriber id of ‘1234567890’ in our app.

We’ll first create a subscriber using the following code:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu(<NOVU_API_KEY>);

export async function sendEmail(email, description) {
    await novu.subscribers.identify('1234567890', {
        email: email,
        firstName: "Subscriber",
    });
}

```

Here, we’re creating a subscriber with the subscriber id of `1234567890` and now we’ll send a notification to the subscriber with this very subscriber id by triggering an email notification like follows:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu(<NOVU_API_KEY>);

export async function sendEmail(email, description) {
    await novu.subscribers.identify('1234567890', {
        email: email,
        firstName: "Subscriber",
    });
    await novu.trigger('email-quickstart', {
        to: {
            subscriberId: '1234567890',
            email: email
        },
        payload: {
            email: email,
            description: description
        }
    });
}

```

We’ve exported this function so that we can use this in the route that we’ll now create.

## Create the route and define a function in that route

Now, create a `pages` directory in the root of the project and create a file in it. Give it a name and remember that it will automatically become a route.

In our case, we’re creating a directory called `api` in our pages directory, and inside `api` we’re creating a file called `sub.js`. In this case, our path will be: `http://localhost:3000/api/sub`

In this file, we simply need to define a function that will handle a POST request to our API. It’ll extract the ‘description’ and ‘email’ variables from the ‘request’ body that will be generated every time we make a POST request and call the function to send an email notification with those plugged in.

We’d used these variables in the workflow we had created in the Novu dashboard and also specified the same in the trigger function above.

The function in our route is quite simple and looks like this:

```jsx theme={null}
import { sendEmail } from '@/app/utils/novu';

export default async function subscribe(req, res) {
  try {
    if (req.method === 'POST') {
      const { email, description } = req.body;
      await sendEmail(email, description);
      await res.status(200).json({ message: 'email working' });
    }
  } catch (error) {
    console.log(error);
    res.status(405).json({ message: 'not working' });
  }
}

```

We can now start our local server and test our backend app on Postman. To start the local server, use the following command:

```bash theme={null}
npm run dev

```

Now, open Postman and send a POST request to the route you created earlier. The exact route depends on the file structure you have followed in the pages directory, but in our case, it is - `http://localhost:3000/api/sub`

Also, make sure that in the body, you’re passing the two variables we’re extracting above, namely - email and description, as follows:

<Frame>
  <img />
</Frame>

> In place of [youremail@gmail.com](mailto:youremail@gmail.com), use your actual email and once you send it, you should see the ‘message: email working’ on the bottom as in the image above.

This means that the email notification was sent successfully. Now go to your inbox and you should see an email notification like the following:

<Frame>
  <img />
</Frame>

## Topics

Novu simplifies the process of triggering notifications to multiple subscribers with an API called "Topics". By utilizing the Topics API, you can effortlessly manage bulk notifications easily.

Each topic is uniquely identified by a custom key specified by the user, serving as the primary identifier for interacting with the Topics API.

This intuitive approach streamlines notifications management, empowering users to focus on delivering targeted messages to their subscribers without the hassle of intricate implementation details.

> Make sure that you use a unique key for a Topic. Keys once used, can’t be changed later!

You have the flexibility to assign a descriptive name to a topic. Unlike the topic key, this name does not require uniqueness and can be modified using the provided API.

A topic can have multiple subscribers associated with it. These subscribers will receive notifications whenever a notification is dispatched to the respective topic.

## Create a topic

You can create a topic using two entities - `key` and `name`. Keys are unique identifiers for topics and a name is just something you assign to a topic for convenience.

```jsx theme={null}
import { Novu } from '@novu/node';

export default async function createTopic(req, res) {
  try {
    const novu = new Novu("<NOVU_API_KEY>");
    if (req.method === 'POST') {
      const { key, name } = req.body;
      const result = await novu.topics.create({ key, name });
      res.status(201).json(result.data);
    }
  } catch (error) {
    console.log(error);
    res.status(500).json({ message: error.message });
  }
}

```

This is a simple function that calls the **`create`** method on the **`topics`** property of the \*\*`novu`\*\*instance. This method creates a new topic in the Novu system using the provided **`key`** and **`name`** values.

If you test this on your local machine, you should get something like this:

<Frame>
  <img />
</Frame>

> Note how the return object contains the key I sent from my request body. That signals successful creation!

## Add subscriber to a Topic

The code for adding a subscriber to a previously created topic is as follows:

<Note>
  You can only add those subscribers to a topic that you've already created. You can see all the subscribers in the [Novu web dashboard](https://web.novu.co/subscribers)?utm\_campaign=docs-quick-nextjs
</Note>

```jsx theme={null}
import { Novu } from '@novu/node';

export default async function addSub(req, res) {
  try {
    const novu = new Novu("<NOVU_API_KEY>");
    if (req.method === 'POST') {
      // Get the subscriber ID from the request body
      const subscriberId = req.body.subscriberId;
      // Get the topic key from the request body
      const topicKey = req.body.topicKey;
      // Call Novu SDK to add the subscriber to the topic
      const result = await novu.topics.addSubscribers(topicKey, {
        subscribers: [subscriberId],
      });
      // Return the result as JSON response
      res.status(200).json(result.data);
    }
  } catch (error) {
    console.log(error);
    res.status(500).json({ message: error.message });
  }
}

```

If you see the code above closely, you’ll see that we first establish a connection to Novu using the Novu API key.

Then we extract `subscriberID` and topicKey from the request body and call the **`addSubscribers`** method on the **`topics`** property of the **`novu`** instance, passing the topic key and an object with an array of subscribers.

This adds the subscriber with the `subscriberID` we’d passed to the array of subscribers, which in the above case contains just one subscriber.

If you check this on Postman, the returned array will contain the `subscriberID` that we had passed in the request body, signalling that it was added to the topic successfully.

If, on the other hand, you find the passed `subscriberId` in the `notFound` array inside the `failed` object, it means the subscriber wasn't added to the topic.

You can read more about it [here](https://docs.novu.co/platform/topics/#subscribers-management-in-a-topic).

The image below shows the case where the subscriber has been added successfully:

<Frame>
  <img />
</Frame>

After creating a topic and adding subscribers to the topic, we’ll now proceed to send a notification to all subscribers (we only have one subscriber in our topic though) of a topic. This is what Topics are used for - sending bulk notifications.

## Sending notifications to a topic

Sending notifications to a topic is not a complex task. You need to extract the topic key to which you want to send notifications and trigger Novu’s method on that topic key with the message in the payload:

```jsx theme={null}
import { Novu } from '@novu/node';

export default async function sendNotifToSub(req, res) {
  try {
    const novu = new Novu("<NOVU_API_KEY>");
    if (req.method === 'POST') {
      // Get the topic key from the request body
      const topicKey = req.body.topicKey;
      const email = req.body.email;
      const description = req.body.description;

      // Call Novu SDK to trigger a notification to the topic subscribers
      const result = await novu.trigger('email-quickstart', {
        to: [{ type: 'Topic', topicKey: topicKey }],
        payload: {
          email: email,
          description: description,
        },
      });
      // Return the result as JSON response
      res.json(result.data);
    }
  } catch (error) {
    console.log(error);
    res.status(500).json({ message: error.message });
  }
}

```

Testing this on Postman should give you something like this:

<Frame>
  <img />
</Frame>

If you see this, then it means the notification was sent successfully, as can be seen in my inbox down below:

<Frame>
  <img />
</Frame>

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, and workflow, configured a channel provider, triggered a single notification, and sent an email notification.


# NodeJS quickstart
Source: https://v0.x-docs.novu.co/quickstarts/nodejs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Node.js.

Welcome to the Node.js Quickstart guide for Novu, a powerful notification service that enables you to send multi-channel (SMS, Email, Chat, Push) notifications from your Node.js applications. In this Quickstart, you'll learn how to seamlessly integrate Novu into your app and perform various essential tasks. Let's get started!

## Prerequisites

Before diving into the Quickstart, make sure you have the following:

* Node.js installed on your development machine.
* A Novu account. If you don't have one, sign up for free at [the web dashboard](https://web.novu.co/?utm_campaign=docs-quick-nodejs)

You can also [view the completed code](https://github.com/novuhq/nodejs-sdk-quickstart) of this quick start in a GitHub repo.

## Install and Set Up Novu in your Node.js App

First, you must install the Novu package in your Node.js application. Open your terminal and run the following command:

```bash theme={null}
npm install @novu/node

```

Once installed, you can import Novu into your app and initialize it using your Novu account credentials. This step establishes a connection between your app and the Novu notification service.

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');
```

Replace the `<NOVU_API_KEY>` value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-nodejs).

🔑 Note: Please do not hardcode your credentials in a file in production. Use environment variables instead.

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-nodejs) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favorite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Workflow

A workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Note: Proper authorization needs to be set for the Chat channel for subscribers.

Please proceed to create a workflow.

1. Click “Workflows” on the left sidebar of your Novu dashboard.
2. Click the “Create Workflow” button on the top right.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select "Email" as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

6. Click on the “Test” tab and send a test email to verify your workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. Yaaay, you have successfully sent your first notification via the Novu dashboard! Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click “Subscribers” on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```jsx theme={null}
// Create a subscriber
const subscriberId = '7789'; // Replace this with a unique user ID that matches your database.
await novu.subscribers.identify(subscriberId, {
  email: 'abc@gmail.com', // optional
  firstName: 'John', // optional
  lastName: 'Doe', // optional
  phone: '', // optional
  avatar: '', // optional
  locale: '', // optional
  data: { customKey1: 'customVal1', customKey2: 'customVal2' }, // optional
});
```

Run the code in your terminal like so:

```bash theme={null}
node index.js

```

You should see the subscriber on your Novu dashboard.

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `updateSubscriber` method like so:

```jsx theme={null}
// Update subscriber detail
await novu.subscribers.update('7789', {
  // new email
  email: 'validemail@gmail.com', // optional
  // new phone
  phone: '+19874567832', // optional
});
```

Other valid fields that can be updated are `phone`, `avatar`, and `data` . The `data` field can accept an array of metadata that you want to attach to the subscriber.

Note: To make all of your app users subscribers, you need to programmatically add them to Novu.

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```jsx theme={null}
const notificationWorkflowId = 'first-email';

novu.trigger(notificationWorkflowId, {
  to: {
    subscriberId: '7789',
  },
  payload: {},
});
```

Before running the code, make sure you understand the following:

* The value of `notificationWorkflowId` should be the workflow's trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriber ID.

Run the code to trigger a notification!

```bash theme={null}
node index.js

```

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called "Topics" and allows users to manage their bulk notifications without having to implement complex loops. A topic is identified by a custom key that is provided by the user, and this key will be the identifier used in the Topics API.

⚠️ DANGER: The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.

Users can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed using the API.

A topic can have different subscribers, who will receive a notification whenever a notification is sent to the topic.

## Create a topic

Copy and paste the following code into your app to create a topic:

```jsx theme={null}
const result = await novu.topics.create({
  key: 'unique-topic-identifier',
  name: 'descriptive-topic-name',
});
```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add Subscribers To A Topic

Copy and paste the following code into your app to add subscribers to a topic.

```jsx theme={null}
const topicKey = '<YOUR TOPIC KEY>';

const response = await novu.topics.addSubscribers(topicKey, {
  subscribers: ['subscriber-id-1', 'subscriber-id-2', ...],
});
```

* To add multiple subscribers to a topic, simply separate their names with commas and add them to the array as part of the `subscribers` value.

## Send Notification To A Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, use Novu's API as follows:

```jsx theme={null}
const topicKey = '<TOPIC_KEY>';
const notificationTemplateId = '<WORKFLOW_TRIGGER_IDENTIFIER>';

await novu.trigger(notificationTemplateId, {
  to: [{ type: 'Topic', topicKey: topicKey }],
  payload: {},
});
```

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider, triggered a single notification, created a topic, added a subscriber to a topic and even triggered a notification to a topic in your application.


# Quickstarts
Source: https://v0.x-docs.novu.co/quickstarts/overview

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with any language/framework of your choice.

<CardGroup>
  <Card title="Vue" icon="vuejs" href="/quickstarts/vue">
    Embed a real-time notification center component in your Vue application.
  </Card>

  <Card title="React" icon="react" href="/quickstarts/react">
    Embed a real-time notification center component in your React application.
  </Card>

  <Card title="Angular" icon="angular" href="/quickstarts/angular">
    Embed a real-time notification center component in your Angular application.
  </Card>

  <Card title="VanillaJS" icon="js" href="/quickstarts/vanillajs">
    Embed a real-time notification center component in your VanillaJS
    application.
  </Card>

  <Card
    title="RedwoodJS"
    icon={
  <svg
    xmlns="http://www.w3.org/2000/svg"
    width="25"
    height="23"
    viewBox="0 0 256 277"
  >
    <path
      fill="#FFF"
      d="M112.39 3.928C101.983 9.164 80.046 19.36 68.16 27.493c-11.885 8.134-10.407 15.711-15.61 20.948c-5.203 5.237-20.814 18.329-31.22 26.184c-10.407 7.855-7.806 28.803-10.407 36.658c-2.602 7.855-7.806 26.184-10.407 34.04c-2.602 7.855 5.203 18.329 10.407 28.802c5.203 10.474 18.211 39.277 23.415 49.75c5.203 10.474 20.813 5.237 33.822 15.71c13.009 10.475 31.22 23.568 44.229 31.423c13.008 7.855 18.212 7.855 31.22 0c13.009-7.855 31.22-20.948 44.23-31.422c13.008-10.474 28.618-5.237 33.822-15.71c5.203-10.474 18.211-39.277 23.415-49.75c5.203-10.474 13.008-20.948 10.406-28.803c-2.602-7.856-7.804-26.185-10.406-34.04c-2.602-7.855 0-28.803-10.407-36.658s-22.487-17.857-31.22-26.184c-8.734-8.327-5.204-13.092-15.61-20.948c-10.407-7.855-33.823-18.329-44.23-23.565c-10.406-5.237-20.813-5.237-31.22 0Z"
    />
    <path
      fill="#BF4722"
      d="m75.644 49.319l48.694 33.238a6.886 6.886 0 0 0 3.7 1.155a6.665 6.665 0 0 0 3.7-1.155l48.73-33.35a6.65 6.65 0 0 0 2.748-5.947a6.633 6.633 0 0 0-3.672-5.418L130.85 13.733a6.692 6.692 0 0 0-5.846 0l-48.546 24.11a6.633 6.633 0 0 0-3.707 5.5a6.649 6.649 0 0 0 2.893 5.976Zm68.933 43.671a6.721 6.721 0 0 0 2.886 5.515l39.037 26.68a6.55 6.55 0 0 0 8.103-.522l32.746-29.288a6.654 6.654 0 0 0 2.213-5.156a6.648 6.648 0 0 0-2.509-5.017L195.787 60.2a6.623 6.623 0 0 0-7.844-.298l-40.48 27.686a6.72 6.72 0 0 0-2.886 5.403Zm-97.09 36.293a6.696 6.696 0 0 1 2.182 5.627a6.524 6.524 0 0 1-3.293 5.068l-23.31 13.973a6.586 6.586 0 0 1-7.5-.512a6.698 6.698 0 0 1-2.195-7.238l8.621-27.127a6.607 6.607 0 0 1 4.551-4.397a6.406 6.406 0 0 1 6.143 1.453l14.8 13.153Zm126.432 2.832l-42.144-28.84a6.622 6.622 0 0 0-7.4 0l-42.145 28.84a6.754 6.754 0 0 0-2.886 5.068a6.88 6.88 0 0 0 2.22 5.44l42.108 37.672a6.597 6.597 0 0 0 4.403 1.677a6.63 6.63 0 0 0 4.403-1.677l42.107-37.672a6.73 6.73 0 0 0 2.183-5.44a6.606 6.606 0 0 0-2.849-5.068Zm-112.41-7.452L28.802 95.375a6.804 6.804 0 0 1-2.22-5.254a6.574 6.574 0 0 1 2.478-5.03l31.266-25.152a6.696 6.696 0 0 1 7.882-.298l40.442 27.685a6.682 6.682 0 0 1 3.01 5.59a6.682 6.682 0 0 1-3.01 5.589l-39 26.68a6.624 6.624 0 0 1-8.14-.522Zm167.95 42.069l-33.302-19.935a6.55 6.55 0 0 0-7.77.745l-40.702 36.33a6.696 6.696 0 0 0-2.13 6.13a6.66 6.66 0 0 0 4.055 5.05l56.463 22.878a6.333 6.333 0 0 0 2.442.485c2.621.008 5-1.54 6.069-3.95l17.501-39.2c1.425-3.102.29-6.787-2.627-8.533Zm4.624-47.658l8.622 27.127h-.074a6.71 6.71 0 0 1-.975 5.958a6.61 6.61 0 0 1-5.353 2.724a6.478 6.478 0 0 1-3.367-.932l-23.348-13.973a6.489 6.489 0 0 1-3.182-5.068a6.62 6.62 0 0 1 2.183-5.627l14.8-13.19a6.59 6.59 0 0 1 6.143-1.454a6.72 6.72 0 0 1 4.551 4.435Zm-123.51 70.91a6.66 6.66 0 0 0-2.109-6.111l-40.701-36.331a6.55 6.55 0 0 0-7.77-.745L26.69 166.732c-2.883 1.754-4.024 5.392-2.664 8.496l17.539 39.2c1.453 3.268 5.21 4.798 8.51 3.465l56.427-22.88a6.659 6.659 0 0 0 4.07-5.03Zm19.98 11.178l45.29 18.333a6.665 6.665 0 0 1 3.997 5.44a6.614 6.614 0 0 1-2.813 6.223l-45.326 31.488a6.551 6.551 0 0 1-3.7 1.191a6.682 6.682 0 0 1-3.7-1.191l-45.29-31.488a6.651 6.651 0 0 1-2.849-6.222a6.775 6.775 0 0 1 4.144-5.44l45.29-18.334a6.69 6.69 0 0 1 4.958 0Z"
    />
  </svg>
}
    href="/quickstarts/redwoodjs"
  >
    Embed a real-time notification center component in your RedwoodJS
    application.
  </Card>

  <Card title="iFrame" icon="html5" href="/quickstarts/iFrame">
    Embed a real-time notification center component in your iFrame application.
  </Card>

  <Card title="Node.js" icon="node" href="/quickstarts/nodejs">
    Connect a Node.js application to Novu.
  </Card>

  <Card
    title="PHP"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#deviconPhp0)" d="M0 64c0 18.593 28.654 33.667 64 33.667c35.346 0 64-15.074 64-33.667c0-18.593-28.655-33.667-64-33.667C28.654 30.333 0 45.407 0 64Z"/><path fill="#777bb3" d="M64 95.167c33.965 0 61.5-13.955 61.5-31.167c0-17.214-27.535-31.167-61.5-31.167S2.5 46.786 2.5 64c0 17.212 27.535 31.167 61.5 31.167Z"/><path d="M34.772 67.864c2.793 0 4.877-.515 6.196-1.53c1.306-1.006 2.207-2.747 2.68-5.175c.44-2.27.272-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.464l-2.473 12.732zM20.173 83.547a.694.694 0 0 1-.68-.828l6.557-33.738a.695.695 0 0 1 .68-.561h14.134c4.442 0 7.748 1.206 9.827 3.585c2.088 2.39 2.734 5.734 1.917 9.935c-.333 1.711-.905 3.3-1.7 4.724a15.818 15.818 0 0 1-3.128 3.92c-1.531 1.432-3.264 2.472-5.147 3.083c-1.852.604-4.232.91-7.07.91h-5.724l-1.634 8.408a.695.695 0 0 1-.682.562z"/><path fill="#fff" d="M34.19 55.826h3.891c3.107 0 4.186.682 4.553 1.089c.607.674.723 2.097.331 4.112c-.439 2.257-1.253 3.858-2.42 4.756c-1.194.92-3.138 1.386-5.773 1.386h-2.786l2.205-11.342zm6.674-8.1H26.731a1.39 1.39 0 0 0-1.364 1.123L18.81 82.588a1.39 1.39 0 0 0 1.363 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.151c2.912 0 5.364-.318 7.287-.944c1.977-.642 3.796-1.731 5.406-3.237a16.522 16.522 0 0 0 3.259-4.087c.831-1.487 1.429-3.147 1.775-4.931c.86-4.423.161-7.964-2.076-10.524c-2.216-2.537-5.698-3.823-10.349-3.823zM30.301 68.557h4.471c2.963 0 5.17-.557 6.62-1.675c1.451-1.116 2.428-2.98 2.938-5.591c.485-2.508.264-4.277-.665-5.308c-.931-1.03-2.791-1.546-5.584-1.546h-5.036l-2.743 14.12m10.563-19.445c4.252 0 7.353 1.117 9.303 3.348c1.95 2.232 2.536 5.347 1.76 9.346c-.322 1.648-.863 3.154-1.625 4.518c-.764 1.366-1.76 2.614-2.991 3.747c-1.468 1.373-3.097 2.352-4.892 2.935c-1.794.584-4.08.875-6.857.875h-6.296l-1.743 8.97h-7.35l6.558-33.739h14.133"/><path d="M69.459 74.577a.694.694 0 0 1-.682-.827l2.9-14.928c.277-1.42.209-2.438-.19-2.87c-.245-.263-.979-.704-3.15-.704h-5.256l-3.646 18.768a.695.695 0 0 1-.683.56h-7.29a.695.695 0 0 1-.683-.826l6.558-33.739a.695.695 0 0 1 .682-.561h7.29a.695.695 0 0 1 .683.826L64.41 48.42h5.653c4.307 0 7.227.758 8.928 2.321c1.733 1.593 2.275 4.14 1.608 7.573l-3.051 15.702a.695.695 0 0 1-.682.56h-7.407z"/><path fill="#fff" d="M65.31 38.755h-7.291a1.39 1.39 0 0 0-1.364 1.124l-6.557 33.738a1.39 1.39 0 0 0 1.363 1.654h7.291a1.39 1.39 0 0 0 1.364-1.124l3.537-18.205h4.682c2.168 0 2.624.463 2.641.484c.132.14.305.795.019 2.264l-2.9 14.927a1.39 1.39 0 0 0 1.364 1.654h7.408a1.39 1.39 0 0 0 1.363-1.124l3.051-15.7c.715-3.686.103-6.45-1.82-8.217c-1.836-1.686-4.91-2.505-9.398-2.505h-4.81l1.421-7.315a1.39 1.39 0 0 0-1.364-1.655zm0 1.39l-1.743 8.968h6.496c4.087 0 6.907.714 8.457 2.14c1.553 1.426 2.017 3.735 1.398 6.93l-3.052 15.699h-7.407l2.901-14.928c.33-1.698.208-2.856-.365-3.474c-.573-.617-1.793-.926-3.658-.926h-5.829l-3.756 19.327H51.46l6.558-33.739h7.292z"/><path d="M92.136 67.864c2.793 0 4.878-.515 6.198-1.53c1.304-1.006 2.206-2.747 2.679-5.175c.44-2.27.273-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.463l-2.475 12.732zM77.54 83.547a.694.694 0 0 1-.682-.828l6.557-33.738a.695.695 0 0 1 .682-.561H98.23c4.442 0 7.748 1.206 9.826 3.585c2.089 2.39 2.734 5.734 1.917 9.935a15.878 15.878 0 0 1-1.699 4.724a15.838 15.838 0 0 1-3.128 3.92c-1.53 1.432-3.265 2.472-5.147 3.083c-1.852.604-4.232.91-7.071.91h-5.723l-1.633 8.408a.695.695 0 0 1-.683.562z"/><path fill="#fff" d="M91.555 55.826h3.891c3.107 0 4.186.682 4.552 1.089c.61.674.724 2.097.333 4.112c-.44 2.257-1.254 3.858-2.421 4.756c-1.195.92-3.139 1.386-5.773 1.386h-2.786l2.204-11.342zm6.674-8.1H84.096a1.39 1.39 0 0 0-1.363 1.123l-6.558 33.739a1.39 1.39 0 0 0 1.364 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.15c2.911 0 5.364-.318 7.286-.944c1.978-.642 3.797-1.731 5.408-3.238a16.52 16.52 0 0 0 3.258-4.086c.832-1.487 1.428-3.147 1.775-4.931c.86-4.423.162-7.964-2.076-10.524c-2.216-2.537-5.697-3.823-10.35-3.823zM87.666 68.557h4.47c2.964 0 5.17-.557 6.622-1.675c1.45-1.116 2.428-2.98 2.936-5.591c.487-2.508.266-4.277-.665-5.308c-.93-1.03-2.791-1.546-5.583-1.546h-5.035Zm10.563-19.445c4.251 0 7.354 1.117 9.303 3.348c1.95 2.232 2.537 5.347 1.759 9.346c-.32 1.648-.862 3.154-1.624 4.518c-.763 1.366-1.76 2.614-2.992 3.747c-1.467 1.373-3.097 2.352-4.892 2.935c-1.793.584-4.078.875-6.856.875h-6.295l-1.745 8.97h-7.35l6.558-33.739h14.133"/><defs><radialGradient id="deviconPhp0" cx="0" cy="0" r="1" gradientTransform="translate(38.426 42.169) scale(84.04136)" gradientUnits="userSpaceOnUse"><stop stopColor="#AEB2D5"/><stop offset=".3" stopColor="#AEB2D5"/><stop offset=".75" stopColor="#484C89"/><stop offset="1" stopColor="#484C89"/></radialGradient></defs></svg>
}
    href="/quickstarts/php"
  >
    Connect a PHP application to Novu.
  </Card>

  <Card
    title="Python"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="34.87" viewBox="0 0 256 255"><defs><linearGradient id="logosPython0" x1="12.959%" x2="79.639%" y1="12.039%" y2="78.201%"><stop offset="0%" stopColor="#387EB8"/><stop offset="100%" stopColor="#366994"/></linearGradient><linearGradient id="logosPython1" x1="19.128%" x2="90.742%" y1="20.579%" y2="88.429%"><stop offset="0%" stopColor="#FFE052"/><stop offset="100%" stopColor="#FFC331"/></linearGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosPython0)" d="M126.916.072c-64.832 0-60.784 28.115-60.784 28.115l.072 29.128h61.868v8.745H41.631S.145 61.355.145 126.77c0 65.417 36.21 63.097 36.21 63.097h21.61v-30.356s-1.165-36.21 35.632-36.21h61.362s34.475.557 34.475-33.319V33.97S194.67.072 126.916.072ZM92.802 19.66a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.13Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosPython1)" d="M128.757 254.126c64.832 0 60.784-28.115 60.784-28.115l-.072-29.127H127.6v-8.745h86.441s41.486 4.705 41.486-60.712c0-65.416-36.21-63.096-36.21-63.096h-21.61v30.355s1.165 36.21-35.632 36.21h-61.362s-34.475-.557-34.475 33.32v56.013s-5.235 33.897 62.518 33.897Zm34.114-19.586a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.131a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13Z"/></svg>
}
    href="/quickstarts/python"
  >
    Connect a Python application to Novu.
  </Card>

  <Card
    title="Kotlin"
    icon={
  <svg
    xmlns="http://www.w3.org/2000/svg"
    width="20"
    height="20"
    viewBox="0 0 256 256"
  >
    <defs>
      <linearGradient
        id="logosKotlinIcon0"
        x1="99.991%"
        x2=".01%"
        y1="-.011%"
        y2="100.01%"
      >
        <stop offset=".344%" stopColor="#E44857" />
        <stop offset="46.89%" stopColor="#C711E1" />
        <stop offset="100%" stopColor="#7F52FF" />
      </linearGradient>
    </defs>
    <path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosKotlinIcon0)" d="M256 256H0V0h256L128 127.949z" />
  </svg>
}
    href="/quickstarts/kotlin"
  >
    Connect a Kotlin application to Novu.
  </Card>

  <Card
    title="Ruby"
    icon={
  <svg xmlns="http://www.w3.org/2000/svg" width="20" height="19.93" viewBox="0 0 256 255"><defs><linearGradient id="logosRuby0" x1="84.75%" x2="58.254%" y1="111.399%" y2="64.584%"><stop offset="0%" stopColor="#FB7655"/><stop offset="0%" stopColor="#FB7655"/><stop offset="41%" stopColor="#E42B1E"/><stop offset="99%" stopColor="#900"/><stop offset="100%" stopColor="#900"/></linearGradient><linearGradient id="logosRuby1" x1="116.651%" x2="1.746%" y1="60.89%" y2="19.288%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby2" x1="75.774%" x2="38.978%" y1="219.327%" y2="7.829%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby3" x1="50.012%" x2="66.483%" y1="7.234%" y2="79.135%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E57252"/><stop offset="46%" stopColor="#DE3B20"/><stop offset="99%" stopColor="#A60003"/><stop offset="100%" stopColor="#A60003"/></linearGradient><linearGradient id="logosRuby4" x1="46.174%" x2="49.932%" y1="16.348%" y2="83.047%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E4714E"/><stop offset="56%" stopColor="#BE1A0D"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby5" x1="36.965%" x2="49.528%" y1="15.594%" y2="92.478%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="18%" stopColor="#E46342"/><stop offset="40%" stopColor="#C82410"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby6" x1="13.609%" x2="85.764%" y1="58.346%" y2="-46.717%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="54%" stopColor="#C81F11"/><stop offset="99%" stopColor="#BF0905"/><stop offset="100%" stopColor="#BF0905"/></linearGradient><linearGradient id="logosRuby7" x1="27.624%" x2="50.745%" y1="21.135%" y2="79.056%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="31%" stopColor="#DE4024"/><stop offset="99%" stopColor="#BF190B"/><stop offset="100%" stopColor="#BF190B"/></linearGradient><linearGradient id="logosRuby8" x1="-20.667%" x2="104.242%" y1="122.282%" y2="-6.342%"><stop offset="0%" stopColor="#BD0012"/><stop offset="0%" stopColor="#BD0012"/><stop offset="7%" stopColor="#FFF"/><stop offset="17%" stopColor="#FFF"/><stop offset="27%" stopColor="#C82F1C"/><stop offset="33%" stopColor="#820C01"/><stop offset="46%" stopColor="#A31601"/><stop offset="72%" stopColor="#B31301"/><stop offset="99%" stopColor="#E82609"/><stop offset="100%" stopColor="#E82609"/></linearGradient><linearGradient id="logosRuby9" x1="58.792%" x2="11.964%" y1="65.205%" y2="50.128%"><stop offset="0%" stopColor="#8C0C01"/><stop offset="0%" stopColor="#8C0C01"/><stop offset="54%" stopColor="#990C00"/><stop offset="99%" stopColor="#A80D0E"/><stop offset="100%" stopColor="#A80D0E"/></linearGradient><linearGradient id="logosRubya" x1="79.319%" x2="23.088%" y1="62.754%" y2="17.888%"><stop offset="0%" stopColor="#7E110B"/><stop offset="0%" stopColor="#7E110B"/><stop offset="99%" stopColor="#9E0C00"/><stop offset="100%" stopColor="#9E0C00"/></linearGradient><linearGradient id="logosRubyb" x1="92.88%" x2="59.841%" y1="74.122%" y2="39.704%"><stop offset="0%" stopColor="#79130D"/><stop offset="0%" stopColor="#79130D"/><stop offset="99%" stopColor="#9E120B"/><stop offset="100%" stopColor="#9E120B"/></linearGradient><linearGradient id="logosRubyc" x1="56.57%" x2="3.105%" y1="101.717%" y2="11.993%"><stop offset="0%" stopColor="#8B2114"/><stop offset="0%" stopColor="#8B2114"/><stop offset="43%" stopColor="#9E100A"/><stop offset="99%" stopColor="#B3100C"/><stop offset="100%" stopColor="#B3100C"/></linearGradient><linearGradient id="logosRubyd" x1="30.87%" x2="92.471%" y1="35.599%" y2="100.694%"><stop offset="0%" stopColor="#B31000"/><stop offset="0%" stopColor="#B31000"/><stop offset="44%" stopColor="#910F08"/><stop offset="99%" stopColor="#791C12"/><stop offset="100%" stopColor="#791C12"/></linearGradient><radialGradient id="logosRubye" cx="32.001%" cy="40.21%" r="69.573%" fx="32.001%" fy="40.21%"><stop offset="0%" stopColor="#A80D00"/><stop offset="0%" stopColor="#A80D00"/><stop offset="99%" stopColor="#7E0E08"/><stop offset="100%" stopColor="#7E0E08"/></radialGradient><radialGradient id="logosRubyf" cx="13.549%" cy="40.86%" r="88.386%" fx="13.549%" fy="40.86%"><stop offset="0%" stopColor="#A30C00"/><stop offset="0%" stopColor="#A30C00"/><stop offset="99%" stopColor="#800E08"/><stop offset="100%" stopColor="#800E08"/></radialGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby0)" d="m197.467 167.764l-145.52 86.41l188.422-12.787L254.88 51.393l-57.414 116.37Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby1)" d="M240.677 241.257L224.482 129.48l-44.113 58.25l60.308 53.528Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby2)" d="m240.896 241.257l-118.646-9.313l-69.674 21.986l188.32-12.673Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby3)" d="m52.744 253.955l29.64-97.1L17.16 170.8l35.583 83.154Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby4)" d="M180.358 188.05L153.085 81.226l-78.047 73.16l105.32 33.666Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby5)" d="m248.693 82.73l-73.777-60.256l-20.544 66.418l94.321-6.162Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby6)" d="M214.191.99L170.8 24.97L143.424.669l70.767.322Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby7)" d="m0 203.372l18.177-33.151l-14.704-39.494L0 203.372Z"/><path fill="#FFF" d="m2.496 129.48l14.794 41.963l64.283-14.422l73.39-68.207l20.712-65.787L143.063 0L87.618 20.75c-17.469 16.248-51.366 48.396-52.588 49c-1.21.618-22.384 40.639-32.534 59.73Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby8)" d="M54.442 54.094c37.86-37.538 86.667-59.716 105.397-40.818c18.72 18.898-1.132 64.823-38.992 102.349c-37.86 37.525-86.062 60.925-104.78 42.027c-18.73-18.885.515-66.032 38.375-103.558Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby9)" d="m52.744 253.916l29.408-97.409l97.665 31.376c-35.312 33.113-74.587 61.106-127.073 66.033Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubya)" d="m155.092 88.622l25.073 99.313c29.498-31.016 55.972-64.36 68.938-105.603l-94.01 6.29Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyb)" d="M248.847 82.833c10.035-30.282 12.35-73.725-34.966-81.791l-38.825 21.445l73.791 60.346Z"/><path fill="#9E1209" d="M0 202.935c1.39 49.979 37.448 50.724 52.808 51.162l-35.48-82.86L0 202.935Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubye)" d="M155.232 88.777c22.667 13.932 68.35 41.912 69.276 42.426c1.44.81 19.695-30.784 23.838-48.64l-93.114 6.214Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyf)" d="m82.113 156.507l39.313 75.848c23.246-12.607 41.45-27.967 58.121-44.42l-97.434-31.428Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyc)" d="m17.174 171.34l-5.57 66.328c10.51 14.357 24.97 15.605 40.136 14.486c-10.973-27.311-32.894-81.92-34.566-80.814Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyd)" d="m174.826 22.654l78.1 10.96c-4.169-17.662-16.969-29.06-38.787-32.623l-39.313 21.663Z"/></svg>

}
    href="/quickstarts/ruby"
  >
    Connect a Ruby application to Novu.
  </Card>

  <Card
    title=".NET"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 256 256"><g fill="none"><rect width="256" height="256" fill="#512BD4" rx="60"/><path fill="#fff" d="M24.052 168.943c-2.236 0-4.138-.731-5.703-2.194c-1.566-1.501-2.349-3.283-2.349-5.347c0-2.101.783-3.902 2.349-5.403c1.565-1.5 3.466-2.251 5.703-2.251c2.274 0 4.194.751 5.76 2.251c1.603 1.501 2.404 3.302 2.404 5.403c0 2.064-.801 3.846-2.404 5.347c-1.566 1.463-3.486 2.194-5.76 2.194Zm89.415-1.238H98.929l-38.304-59.318a26.371 26.371 0 0 1-2.404-4.672h-.336c.298 1.726.447 5.422.447 11.087v52.903H45.471V87H60.96l37.018 57.912c1.566 2.402 2.572 4.052 3.02 4.953h.223c-.372-2.139-.559-5.759-.559-10.863V87h12.805v80.705Zm62.631 0h-45.014V87h43.225v11.369h-29.916v22.849h27.568v11.312h-27.568v23.863h31.705v11.312Zm63.973-69.336h-23.038v69.336h-13.309V98.369h-22.982V87h59.329v11.369Z"/></g></svg>
}
    href="/quickstarts/.NET"
  >
    Connect a .NET application to Novu.
  </Card>

  <Card
    title="NextJS"
    icon={
  <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 128 128"><path d="M64 0C28.7 0 0 28.7 0 64s28.7 64 64 64c11.2 0 21.7-2.9 30.8-7.9L48.4 55.3v36.6h-6.8V41.8h6.8l50.5 75.8C116.4 106.2 128 86.5 128 64c0-35.3-28.7-64-64-64zm22.1 84.6l-7.5-11.3V41.8h7.5v42.8z"/></svg>
}
    href="/quickstarts/nextjs"
  >
    Connect a NextJS application to Novu.
  </Card>

  <Card title="Go" icon="golang" href="/quickstarts/go">
    Connect a Go application to Novu.
  </Card>

  <Card
    title="Java"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="#0074BD" d="M47.617 98.12s-4.767 2.774 3.397 3.71c9.892 1.13 14.947.968 25.845-1.092c0 0 2.871 1.795 6.873 3.351c-24.439 10.47-55.308-.607-36.115-5.969zm-2.988-13.665s-5.348 3.959 2.823 4.805c10.567 1.091 18.91 1.18 33.354-1.6c0 0 1.993 2.025 5.132 3.131c-29.542 8.64-62.446.68-41.309-6.336z"/><path fill="#EA2D2E" d="M69.802 61.271c6.025 6.935-1.58 13.17-1.58 13.17s15.289-7.891 8.269-17.777c-6.559-9.215-11.587-13.792 15.635-29.58c0 .001-42.731 10.67-22.324 34.187z"/><path fill="#0074BD" d="M102.123 108.229s3.529 2.91-3.888 5.159c-14.102 4.272-58.706 5.56-71.094.171c-4.451-1.938 3.899-4.625 6.526-5.192c2.739-.593 4.303-.485 4.303-.485c-4.953-3.487-32.013 6.85-13.743 9.815c49.821 8.076 90.817-3.637 77.896-9.468zM49.912 70.294s-22.686 5.389-8.033 7.348c6.188.828 18.518.638 30.011-.326c9.39-.789 18.813-2.474 18.813-2.474s-3.308 1.419-5.704 3.053c-23.042 6.061-67.544 3.238-54.731-2.958c10.832-5.239 19.644-4.643 19.644-4.643zm40.697 22.747c23.421-12.167 12.591-23.86 5.032-22.285c-1.848.385-2.677.72-2.677.72s.688-1.079 2-1.543c14.953-5.255 26.451 15.503-4.823 23.725c0-.002.359-.327.468-.617z"/><path fill="#EA2D2E" d="M76.491 1.587S89.459 14.563 64.188 34.51c-20.266 16.006-4.621 25.13-.007 35.559c-11.831-10.673-20.509-20.07-14.688-28.815C58.041 28.42 81.722 22.195 76.491 1.587z"/><path fill="#0074BD" d="M52.214 126.021c22.476 1.437 57-.8 57.817-11.436c0 0-1.571 4.032-18.577 7.231c-19.186 3.612-42.854 3.191-56.887.874c0 .001 2.875 2.381 17.647 3.331z"/></svg>
}
    href="/quickstarts/java"
  >
    Connect a Java application to Novu.
  </Card>
</CardGroup>


# PHP quickstart
Source: https://v0.x-docs.novu.co/quickstarts/php

Use Novu to send multi-channel (SMS, Email, Chat, Push) notifications from a PHP app.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications from a PHP app.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-php) if you don’t have one yet.
* A working PHP development environment with a PHP version of 7.2+.

You can also [v](https://cloudinary.com/documentation/php_quickstart#view_the_completed_code)[iew the completed code](https://github.com/novuhq/novu-php-quickstart) of this quick start in a GitHub repo.

## Install Novu PHP SDK

The [PHP SDK](http://github.com/novuhq/novu-php) provides a fluent and expressive interface for interacting with Novu's API and managing notifications.

Now install the Novu PHP SDK by running the following command in your terminal:

```bash theme={null}
composer require unicodeveloper/novu

```

Otherwise, create a file named `composer.json` and add the following to it:

```php theme={null}
{
    "require": {
        "unicodeveloper/novu": "^1.0"
    }
}

```

Next, install the SDK by running the following `composer` command:

```bash theme={null}
composer install

```

## Initialize & Configure the Novu SDK

Create a new file, `index.php` in your application and add the following code to it:

```php theme={null}
<?php

  require('vendor/autoload.php');

  use Novu\SDK\Novu;

$apiKey = '<NOVU_API_KEY>';
$novu = new Novu($apiKey);
```

Replace the `$apiKey`’s value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-php).

<Note>
  Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-php) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favourite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create A Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **Untitled.** Rename it to a more suitable title.
4. Select **Email** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

6. Click on the “Test” tab and send a test email to verify your workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. Yaaay, you have successfully sent your first notification via the Novu dashboard! Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click “Subscribers” on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```php theme={null}
// Create subscriber
$novu->createSubscriber([
    'subscriberId' => '7789', // replace with system_internal_user_id
    'email' => 'abc@gmail.com',
    'firstName' => 'John', // optional
    'lastName' => 'Doe', // optional
])->toArray();
```

Run the code in your terminal like so:

```bash theme={null}
php index.php

```

You should see the subscriber on your Novu dashboard.

<Frame>
  <img />
</Frame>

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `updateSubscriber` method like so:

```php theme={null}
// Update subscriber detail
$subscriberId = '7789';
$novu->updateSubscriber($subscriberId, [
    'email' => 'validemail@gmail.com',  // replace with valid email
    'firstName' => '<insert-firstname>', // optional
    'lastName' => '<insert-lastname>', // optional
])->toArray();
```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an array of metadata that you want to attach to the subscriber.

<Note>
  To make all of your app users subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```php theme={null}
$novu->triggerEvent([
    'name' => 'first-email',
    'payload' => ['first-name' => 'Adam'],
    'to' => [
        'subscriberId' => '7789'
    ]
])->toArray();
```

Before running the code, make sure you understand the following:

* The value of `name` should be the workflow’s trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriber ID.

Run the code to trigger a notification!

```php theme={null}
php index.php

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safeguards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```php theme={null}
// Create a Topic
$novu->createTopic([
  'key'  => 'frontend-users',
  'name' => 'All frontend users'
]);
```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers to a topic:

```php theme={null}
$topicKey = 'frontend-users';
$subscribers = [
    '6460925ce1a93324257d2fc1',
    '7789'
];

// Add subscribers to a topic
$novu->topic($topicKey)->addSubscribers($subscribers);
```

On the other hand, if you want to remove subscribers from a topic, do the following:

```php theme={null}
$topicKey = 'frontend-users';
$subscribers = [
    '6460925ce1a93324257d2fc1',
    '7789'
];

// Remove subscribers from a topic
$novu->topic($topicKey)->removeSubscribers($subscribers);
```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```php theme={null}
// Send notifications to a topic (all frontend users)
$novu->triggerEvent([
    'name' => 'first-email',
    'to' => [
       [
         'type' => 'Topic',
         'topicKey' => 'frontend-users'
       ]
    ]
])->toArray();
```

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider and triggered a notification in your application.


# Python quickstart
Source: https://v0.x-docs.novu.co/quickstarts/python

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Python.

In this guide, you'll learn how to use Novu in a Python application. Let's see how you can seamlessly integrate Novu into your Python project!

## Prerequisites

Before diving into the Quickstart, make sure you have the following:

* Python3 installed on your development machine.
* A Novu account. If you don't have one, sign up for free at [web.novu.co](https://web.novu.co?utm_campaign=docs-gs-quick-python)

## Install and Set Up Novu in your Python Project

First, you must install the Novu package in your Python project. From your terminal, you can install the Novu package in your project by running either of the following two commands:

Via pip

```bash theme={null}
pip install novu

```

Via poetry

```bash theme={null}
poetry add novu

```

Once installed, you can import Novu into your project and initialize it using your Novu account credentials. This step establishes a connection between your app and the Novu notification service.

```python theme={null}
from novu.config import NovuConfig

NovuConfig().configure("https://api.novu.co", "<NOVU_API_KEY>")

```

Replace the `<NOVU_API_KEY>` value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-python).

<Note>Please do not hardcode your credentials in a file in production. Use environment variables instead.</Note>

## Set Up A Channel Provider

A channel provider is a service that lets you use one or more notification channels such as sending an email, SMS, push notification etc. Our integration store currently supports four channels: Email, SMS, Chat, and Push. Each of these channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel** at a time. Connect anyone of your preferred providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Notification Workflow

A notification workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber.

The workflow includes the following:

* Notification workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>Proper authorization needs to be set for the Chat channel for subscribers.</Note>

To create a notification workflow, please follow the following steps:

1. Click **Workflows** on the left sidebar of your Novu dashboard.

2. Click the **Add a Workflow** button on the top left.

3. Select **blank workflow** from the dropdown.

4. The name of a new workflow is currently "Untitled." Rename it to a suitable title.

5. Select any channel you want to use in your app. For the sake of this guide, we'll be using the 'Email' channel.
   <Frame>
     <img alt="Set email" />
   </Frame>

6. Click on the recently added channel, fill the email subject and click “Update”.
   <Frame>
     <img alt="Update email template" />
   </Frame>

7. Click on the “Test” tab and send a test email to verify your notification workflow.
   <Frame>
     <img alt="Send test email" />
   </Frame>

You should get an email within seconds. If you didn't, please check your 'spam' folder as sometimes test emails can end up there. Yaaay, you have successfully sent your first notification via the Novu dashboard!

Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display only one subscriber, as you were added automatically during sign-up. If default subscriber is not created, checkout [how to create new subscriber.](/subscribers/subscribers#create-a-subscriber)

<Frame>
  <img alt="Subscriber id" />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```python theme={null}
## Create a subscriber

from novu.api.subscriber import SubscriberApi
from novu.dto.subscriber import SubscriberDto

your_subscriber_id = "123" # Replace this with a unique user ID.

## Define a subscriber instance
subscriber = SubscriberDto(
   subscriber_id=your_subscriber_id,
   email="abc@gmail.com",
   first_name="John",
   last_name="Doe"
)

SubscriberApi().create(subscriber)

```

Run the code in your terminal like so:

```bash theme={null}
python main.py # replace main.py with your file name

```

You should see a new subscriber (that you created above) on your Novu dashboard.

## Update A Subscriber

To update the Subscriber details you can call the put method from SubcriberApi. Here is an example:

```python theme={null}
## Update subscriber detail

from novu.api.subscriber import SubscriberApi
from novu.dto.subscriber import SubscriberDto

subscriber = SubscriberDto(
   subscriber_id="123",
   email="new.abc@gmail.com",
   first_name="New",
   last_name="Name"
)

SubscriberApi().put(subscriber)

```

<Note>To send notifications to all your users, you'll need to make them subscribers in Novu, which you can do by programmatically adding them to Novu.</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```python theme={null}
from novu.api import EventApi

EventApi().trigger(
    name="test",  # The trigger ID of the workflow. It can be found on the workflow page.
    recipients="123",
    payload={},  # Your Novu payload goes here
)

```

Before running the code, make sure you understand the following:

* The value of `name` should be the notification workflow's trigger ID/slug.

<Frame>
  <img alt="Trigger id" />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the notification template content.
* The value of `recipients` is the id of the subscriber on Novu. Replace `123` with your subscriber ID.

Run the code to trigger a notification!

```bash theme={null}
python main.py # replace main.py with your file name

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```python theme={null}
from novu.api import TopicApi

## Create a topic
TopicApi().create(
    key="new-customers", name="New business customers"
)

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```python theme={null}
from novu.api import TopicApi

## Add a list of subscribers to a topic
TopicApi().subscribe(key="new-customers", subscribers="<LIST_OF_SUBSCRIBER_IDs>")

```

On the other hand, if you want to remove subscribers from a topic, do the following:

```python theme={null}
from novu.api import TopicApi

## Unsubscribe a list of subscribers from a topic
TopicApi().unsubscribe(key="new-customers", subscribers="<LIST_OF_SUBSCRIBER_IDs>")

```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```python theme={null}
from novu.api import EventApi
from novu.dto.topic import TriggerTopicDto

topics = TriggerTopicDto(
   topic_key="new-customers",
   type="Topic",
)

EventApi().trigger_topic(
    name="test",  # The trigger ID of the workflow. It can be found on the workflow page.
    topics=topics,
    payload={},  # Your Novu payload goes here
)

```

## Next Steps

Great job! If you've reached this point, you should now have successfully set up a channel provider, created a notification workflow, created a subscriber, updated a subscriber and triggered a notification in your application.

To learn more about notifications and explore Novu's features and capabilities, check out:

* [Novu Digest Engine](/workflows/digest) - Learn how to aggregate multiple trigger events into a single message and deliver it to the subscriber.
* [Novu Python SDK](https://github.com/novuhq/novu-python) - Delve deeper into the SDK and explore a lot of features.
* [Novu Python Cookbook](https://novu-python.readthedocs.io/en/latest/) - Learn how to use the SDK features.


# React
Source: https://v0.x-docs.novu.co/quickstarts/react

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with React.

Send notifications across different channels (SMS, Email, Chat, Push) and enable real-time In-App notifications with the help of a rich and customizable Notification Center.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-react) if you don’t have one yet.
* A working React development environment.

You can find the code for this project [here](https://github.com/novuhq/react-quickstart)

## Install the Novu React Notification Center Package in your React app

The Novu React package provides a React component library that you can use to add a fully functioning notification center to your React application.

To use it, first, install the React Notification Center package by running the following command in your terminal:

```bash theme={null}
npm install @novu/notification-center

```

Before you can use Novu in your React app, you'll need two things:

1. Create a workflow to use for sending notifications, and
2. Create a subscriber - recipient of notifications.

## Create a workflow

Before triggering a notification, we need to create a workflow. A workflow is like a blueprint that all the notifications are supposed to follow.

> The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

These are the steps to create a workflow:

1. Click **Workflow** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **"Untitled"**. Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.

   <Frame>
     <img />
   </Frame>
5. Click on the recently added "In-App" channel and configure it according to your preferences. Once you're done, click "Update" to save your configuration.

   <Frame>
     <img />
   </Frame>

   I'll briefly explain the function of each label in the image above:

* **1-Preview**: This shows you a glimpse of how each notification item will look in the Notification Center UI.
* **2-Avatar**: If turned on, each notification item will show the avatar of the subscriber.
* **3-Action**: With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds**: This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL**: This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter**: This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).
* **7-Editor**: You can add text that you want to be displayed in each notification item. Additionally, you can specify custom variables using `{{ }}`. This means you can inject variables from your code into a notification item's text via a payload.

In our case, we'll use the custom variables functionality, as shown below:

<Frame>
  <img />
</Frame>

Feel free to add only text for now and rename the workflow to quick start. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

<Frame>
  <img />
</Frame>

Now, we’ll learn how to create subscribers on Novu - Recipients of Notifications!

## Create a subscriber

If you click “Subscriber” on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-react), you’ll see the subscriber list. By default, there will only be one subscriber as you’re automatically added as a subscriber when you sign up for Novu:

<Frame>
  <img />
</Frame>

<Note>If you don't see the default subscriber, follow [how to create subscriber](/subscribers/subscribers#create-a-subscriber) documentation to learn on how to create one </Note>

Now, let’s create a subscriber on Novu. After creating a subscriber, we’ll trigger a notification to this subscriber. Subscribers are identified by a unique `subscriberId`.

With Novu, you can create a subscriber using any of its SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin). The NodeJS code to create a subscriber in Novu is:

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<NOVU_API_KEY>");

await novu.subscribers.identify("789", {
  firstName: "Sumit",
  lastName: "Saurabh",
});
```

The `identify` method used above either updates an existing subscriber using the payload data if a subscriber with the same `subscriberId` already exists, or creates a new one if it doesn't. Here, since no subscriber with `firstName` of `Sumit` and `lastName` of `Saurabh` exists, a new one was created and we can now send a notification to this subscriber by triggering a workflow.

<Info>
  You can read more about the `identify` method in our
  [docs](https://docs.novu.co/subscribers/subscribers#create-a-subscriber)
</Info>

You can get your API key from the Novu dashboard. Replace `<NOVU_API_KEY>` with it. Now, head over to the Novu dashboard and see the newly created subscriber above with a `subscriberId` of `789`.

You can also update information about an already existing subscriber using the `subscriber.update` method as shown below:

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<NOVU_API_KEY>");

await novu.subscribers.update("789", {
  firstName: "Saurabh", // new first name
  lastName: "Sumit", // new last name
});
```

## Using Novu in a React app

We have already installed the Novu notification center package above. To use it in an app, simply import it and add the component to your React app as follows:

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
} from "@novu/notification-center";

function App() {
  return (
    <>
      <NovuProvider
        subscriberId={process.env.REACT_APP_SUB_ID}
        applicationIdentifier={process.env.REACT_APP_APP_ID}
      >
        <PopoverNotificationCenter>
          {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
        </PopoverNotificationCenter>
      </NovuProvider>
    </>
  );
}

export default App;
```

You'll notice two things used above - `applicationIdentifier` and `subscriberID`.

An application identifier is a public key used to identify your application. You can get your own application identifier from the [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-react).

And subscribers are users to whom notifications will be sent. They are identified by a `subscriberID` which you can also find in the [Novu subscribers dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-react).

## Trigger a notification

We can trigger a notification by simply running the code below with the correct credentials;

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<API_KEY>");

novu.trigger("quickstart", {
  to: {
    subscriberId: "789",
  },
  payload: {
    description: "Test notification",
  },
});
```

This will take the workflow we created above with the identifier `quickstart` and send a notification to the subscriber with `subscriberId` of `789`.

> Make sure you're executing this code with the correct credentials.

## Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification centre, created a subscriber, a workflow, and triggered a notification in your React application.


# RedwoodJS
Source: https://v0.x-docs.novu.co/quickstarts/redwoodjs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with RedwoodJS.

Send notifications across different channels (SMS, Email, Chat, Push) and enable real-time In-App notifications with the help of a rich and customizable Notification Center in a RedwoodJS app.

Explore the code for [this quickstart on GitHub](https://github.com/novuhq/redwoodjs-quickstart/).

Explore the [live demo](https://novu-redwoodjs-blog.netlify.app/contact).

# Prerequisites

To follow the steps in this quickstart, you'll need:

* A Novu account. If you don't have one, [sign up for free](https://web.novu.co?utm_campaign=docs-gs-quick-redwoodjs).
* Node.js installed on your development machine.

# Create a RedwoodJS app

Clone the popular RedwoodJS blog tutorial app by running the following command in your terminal:

```bash theme={null}
git clone https://github.com/redwoodjs/redwood-tutorial
cd redwood-tutorial
yarn install
yarn rw prisma migrate dev
yarn rw prisma db seed
yarn rw dev

```

# Install Novu

To install Novu's In-App notification center, simply issue the following command:

```bash theme={null}
yarn workspace web add @novu/notification-center

```

Next, install Novu's Node SDK to fire notifications from the api/backend:

```bash theme={null}
yarn workspace api add @novu/node

```

## Register The Notification Center Component

Head over to `web/src/layouts/BlogLayout/BlogLayout.js` file of the recently cloned project and add the Novu In-App Notification center.

The file should look like this:

```javascript theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
} from "@novu/notification-center";

import { Link, routes } from "@redwoodjs/router";

import { useAuth } from "src/auth";

const BlogLayout = ({ children }) => {
  const { logOut, isAuthenticated, currentUser } = useAuth();
  const SUBSCRIBER_ID = process.env.REDWOOD_ENV_SUBSCRIBER_ID;
  const APPLICATION_IDENTIFIER = process.env.REDWOOD_ENV_APPLICATION_IDENTIFIER;

  return (
    <>
      <header className="relative flex justify-between items-center py-4 px-8 bg-blue-700 text-white">
        <h1 className="text-5xl font-semibold tracking-tight">
          <Link
            className="text-blue-400 hover:text-blue-100 transition duration-100"
            to={routes.home()}
          >
            Redwood Blog with <em>Novu</em>
          </Link>
        </h1>
        <nav>
          <ul className="relative flex items-center font-light">
            <li>
              <NovuProvider
                subscriberId={SUBSCRIBER_ID}
                applicationIdentifier={APPLICATION_IDENTIFIER}
              >
                <PopoverNotificationCenter
                  showUserPreferences={true}
                  position="top-start"
                >
                  {({ unseenCount }) => (
                    <NotificationBell unseenCount={unseenCount} />
                  )}
                </PopoverNotificationCenter>
              </NovuProvider>
            </li>
            <li>
              <Link
                className="py-2 px-4 hover:bg-blue-600 transition duration-100 rounded"
                to={routes.about()}
              >
                About
              </Link>
            </li>
            <li>
              <Link
                className="py-2 px-4 hover:bg-blue-600 transition duration-100 rounded"
                to={routes.contact()}
              >
                Contact
              </Link>
            </li>
            <li>
              {isAuthenticated ? (
                <div>
                  <button type="button" onClick={logOut} className="py-2 px-4">
                    Logout
                  </button>
                </div>
              ) : (
                <Link to={routes.login()} className="py-2 px-4">
                  Login
                </Link>
              )}
            </li>
          </ul>
          {isAuthenticated && (
            <div className="absolute bottom-1 right-0 mr-12 text-xs text-blue-300">
              {currentUser.email}
            </div>
          )}
        </nav>
      </header>
      <main className="max-w-4xl mx-auto p-12 bg-white shadow rounded-b">
        {children}
      </main>
    </>
  );
};

export default BlogLayout;
```

<Note>
  Add `REDWOOD_ENV_APPLICATION_IDENTIFIER` and `REDWOOD_ENV_SUBSCRIBER_ID` to
  the `.env` file.
</Note>

The `Subscriber ID` ideally should be the `id` of the **logged in user**. When a user logs into your app, they’ll be able to see all their notifications in the notification center. For this to work successfully, the user should have been created as a subscriber on Novu.

The `Application Identifier` is a public key used to identify your application.

Head over to your [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-redwoodjs), copy the application identifier and add it as the value of `REDWOOD_ENV_APPLICATION_IDENTIFIER`.

Head over to [the Subscribers page](https://web.novu.co/subscribers?utm_campaign=docs-quick-redwoodjs), grab a subscriber identifier and add it as the value of `REDWOOD_ENV_SUBSCRIBER_ID` in the `.env` file.

Now, check your app, you will see a notification bell button. Click on the button to reveal the notification center UI. Voila!

<Note>
  There are no notifications because none has been triggered yet. When
  notifications are sent to a subscriber, it will show up in the UI. Next, we'll
  learn how to trigger notifications.
</Note>

# Create A Workflow

The first step to trigger notifications is to create a workflow. A workflow is like a map that holds the entire flow of messages sent to the subscriber.

<Note>The recipients of a triggered notification are called subscribers.</Note>

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Add a workflow** button on the top left.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.
5. Click on the recently added In-App channel and configure it.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).

In the In-App channel `Editor`, add the following content and rename the step to `Onboarding In App` :

```javascript theme={null}
Hi {{ name }},
<br/>
<p>Thanks for indicating interest in attending RedwoodJS conference. Here is your message: </p>

<p>{{ message }}</p>

```

<Note>
  `{{ name }}` and `{{ message }}` are payload values that will be passed on from
  our code to the workflow template so it can appear in the notification sent to
  subscribers.
</Note>

Click on the `Update` button to save the configuration successfully!

6. In the workflow page, drag and drop the **Email** channel to the workflow canvas to be just below the `In-App` channel.
7. Click on the recently added Email channel and configure it:

Add `Sender name` and `Subject`. Ensure the `Default Layout` is selected for the Email Layout.

Switch to the `Custom Code` section and add the following:

```javascript theme={null}
Hi {{ name }},

<br />
<p>Thank you for attending RedwoodJS Conference. This means a lot to us!</p>
<br />
<p>Here is your message:</p>

{{ message }}

```

Finally, give the workflow a name. We'll need the workflow trigger identifier ***(which is the slug of the name)*** later.

Next, we’ll learn how to trigger notifications to subscribers.

# Trigger A Notification

Open up `api/src/services/contacts/contacts.js`, and add the following code into your app to trigger a notification:

```javascript theme={null}
import { Novu } from '@novu/node'

const novu = new Novu(process.env.NOVU_API_KEY)

export async function sendNotification(email, name, message) {
  await novu.trigger('<workflow-trigger-id>', {
    to: {
      subscriberId: process.env.REDWOOD_ENV_SUBSCRIBER_ID,
      email: email,
    },
    payload: {
      name: name,
      message: message,
    },
  })
}

...

...

/** In the createContact code, call the sendNotification and pass in the email, name and message */
export const createContact = ({ input }) => {
  validate(input.email, 'email', { email: true })

  sendNotification(input.email, input.name, input.message)

  return db.contact.create({
    data: input,
  })
}

...
...

```

Before running the code, make sure you understand the following:

* The value of `<workflow-trigger-id>` should be the workflow’s trigger ID/slug.
* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu.
* Ensure `NOVU_API_KEY` is in the `.env` file and with the appropriate value gotten from the dashboard.

# One more thing

Head over to the [integrations store on your Novu dashboard](https://web.novu.co/integrations?utm_campaign=docs-quick-redwoodjs).

Select the **Novu Email Test Provider**, and mark as the primary provider for Emails. This ensures that all emails are sent via the Novu Email provider.

# Test the app

Ensure your app is still running and head over the `/contact` page in the app. Fill the form and click `Save`.

The app will trigger two notifications:

* An In-App notification
* An Email notification

# Conclusion

Great job! If you've reached this point, you should now have successfully created workflow, configured a channel provider, triggered a workflow, and sent an email and In-App notification.


# Ruby quickstart
Source: https://v0.x-docs.novu.co/quickstarts/ruby

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Ruby.

Learn how to integrate Novu into your Ruby project on the fly and send notifications across different channels (SMS, Email, Chat, Push).

Let's get started! 💪

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-ruby) if you don’t have one yet.
* A working Ruby development environment with at least version 2.6.0.

You can also [view the completed code](https://github.com/novuhq/novu-ruby-quickstart) of this quick start in a GitHub repo.

## Install Novu Ruby SDK

The [Ruby SDK](http://github.com/novuhq/novu-ruby) provides a fluent and expressive interface for interacting with Novu's API and managing notifications.

You can install the client library via RubyGems:

```ruby theme={null}
gem install novu

```

Or add it to your Gemfile:

```ruby theme={null}
gem 'novu'

```

Then run `bundle install`.

## Initialize & Configure the Novu Ruby SDK

To use the library, Create a new file `index.rb` then initialize the client with your API token:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

```

Replace the `<NOVU_API_KEY>` argument with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-ruby).

<Note>
  Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

To test your API key, call the methods on the client to interact with the Novu API and display the result on your ruby console:

```ruby theme={null}
puts client.notifications

```

Run the file `index.rb`:

```bash theme={null}
ruby index.rb

```

You should see a result as below:

```json theme={null}
{
  "page": 0,
  "totalCount": 0,
  "pageSize": 10,
  "data": []
}

```

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-ruby) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favorite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create A Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.

<Frame>
  <img />
</Frame>

3. The name of the new workflow is currently Untitled, rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select Email as the channel you want to add, by dragging it from the right sidebar.

<Frame>
  <img />
</Frame>

5. Click on the Email in the workflow and edit it as per this image. Don’t forget to add the fields in the editor which is supposed to be updated with dynamic values that will be sent when calling the API.

<Frame>
  <img />
</Frame>

6. Also, add the variables in the Variables section in the test tab and try testing it by sending the email to your email address using the Send Test Email button at the bottom right.

<Frame>
  <img />
</Frame>

You should get an email within seconds! 👌

Great, you have successfully sent your first notification via the Novu dashboard! Now, let’s take a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## Create subscriber

create_payload = {
    'subscriberId' => '7789', # replace with system_internal_user_id
    'firstName' => 'John', # optional
    'lastName' => 'Doe', # optional
}
client.create_subscriber(create_payload)

```

Run the code in your terminal:

```bash theme={null}
ruby index.rb

```

You should see the subscriber on your Novu dashboard.

\![https://res.cloudinary.com/dxc6bnman/image/upload/f\_auto,q\_auto/v1685466979/guides/Screenshot\_2023-05-14\_at\_11.06.38\_ugvmc0.png](https://res.cloudinary.com/dxc6bnman/image/upload/f_auto,q_auto/v1685466979/guides/Screenshot_2023-05-14_at_11.06.38_ugvmc0.png)

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `updateSubscriber` method like so:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## Update subscriber detail

update_payload = {
    'email' => 'validemail@gmail.com',  # replace with valid email
    'firstName' => '<insert-firstname>', # optional
    'lastName' => 'Obasanjo', # optional
}
client.update_subscriber('7789', update_payload);
```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an object of metadata that you want to attach to the subscriber.

<Note>
  To make all of your app users subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## trigger a notification

trigger_payload = {
    'name' => 'Trigger1',
    'payload' => {
        'first-name' => 'Adam'
    },
    'to' => {
        'subscriberId' => '7789'
    }
}
client.trigger_event(trigger_payload)

```

Before running the code, make sure you understand the following:

* The value of `name` should be the workflow’s trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriber ID.

Run the code to trigger a notification!

```bash theme={null}
ruby index.rb

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safeguards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')
## Create a Topic

create_topic_payload = {
    'key'  => 'frontend-users',
    'name' => 'All frontend users'
}
client.create_topic(create_topic_payload)

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add and Remove Subscribers to a Topic

Copy and paste the following code into your app to add subscribers to a topic:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

topicKey = 'frontend-users'
subscribers = ['6460925ce1a93324257d2fc1', '7789'].to_s

## Add subscribers to a topic
client.add_subscribers(topicKey, subscribers)

```

Also, you can remove subscribers from a topic by using the code snippet below:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

topicKey = 'frontend-users'
subscribers = ['6460925ce1a93324257d2fc1', '7789'].to_s

## Remove subscribers from a topic
client.remove_subscribers(topicKey, subscribers)

```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## Send notifications to a topic (all frontend users)
client.trigger_event({
    'name' => 'Trigger1',
    'to' => {
        'type' => 'Topic',
        'topicKey' => 'frontend-users'
    }
})

```

<Note>
  The value of the `name` key in the payload should be the name of the notification created earlier.
</Note>

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider and triggered a notification in your application.


# VanillaJS
Source: https://v0.x-docs.novu.co/quickstarts/vanillajs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with VanillaJS.

Learn how to integrate Novu into your vanilla JS app on the fly. Send notifications across different channels (SMS, Email, Chat, Push) and enable real-time In-App notifications with the help of a rich and customizable Notification Center.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-vanilla) if you don’t have one yet.
* A working Vanilla JS development environment.

You can find the code for this project [here](https://github.com/novuhq/vanillajs-quickstart)

## Loading Notification center component from the CDN

The Notification Center Web Component is a custom element that can be used in any web application.

You can find out more about the web component [here](https://docs.novu.co/notification-center/web-component/).

In our case, we'll be using the bundled version of the Notification Center Web Component that is available on the CDN.

You can load the Notification center component using the CDN as follows:

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    ...
    <!-- CDN link for Novu notification center component -->
    <script src="​https://web-component.novu.co/index.js"></script>
  </head>
  <body>
    <!-- HTML body -->
    <!-- the notification center -->
    <notification-center-component
      style="display: inline-flex"
      application-identifier="<YOUR_APPLICATION_IDENTIFIER>"
      subscriber-id="<YOUR_SUBSCRIBER_ID>"
    ></notification-center-component>
  </body>
</html>

```

You'll notice the use of two things in the above code - `application-identifier` and `subscriber-id`.

An application identifier is a public key used to identify your application. You can get your own application identifier from the [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-vanilla).

And subscribers are users to which notifications will be sent. They are identified by a `subscriberID` which you can also find in the [Novu subscribers dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-vanilla). Let's learn more about subscribers.

## Subscribers in Novu

If you click “Subscriber” on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-vanilla), you’ll see the subscriber list. By default, there will only be one subscriber as you’re automatically added as a subscriber when you sign up for Novu:

<Frame>
  <img />
</Frame>

<Note>If you don't see the default subscriber, follow [how to create subscriber](/subscribers/subscribers#create-a-subscriber) documentation to learn on how to create one </Note>

Now, let’s create a subscriber on Novu. After creating a subscriber, we’ll trigger a notification to this subscriber. Subscribers are identified by a unique `subscriberId`.

With Novu, you can create a subscriber using any of its SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin). The code to create a subscriber in Novu is:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.identify('123', {
  firstName: 'Sumit',
  lastName: 'Saurabh',
  returnUser: true,
});
```

You can get your API key from the Novu dashboard. Replace `<NOVU_API_KEY>` with it. Now, if you’ll go to the Novu dashboard, you shall see the subscriber we created above with `subscriberId` of `123`.

You can also update information about an already existing subscriber using the `subscriber.update` method as shown below:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('123', {
  firstName: 'Saurabh', // new first name
  lastName: 'Sumit', // new last name
});
```

## Create a workflow

Before triggering a notification, we need to create a workflow. A workflow is like a blueprint that all the notifications are supposed to follow.

> The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

These are the steps to create a workflow:

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **"Create Workflow"** button on the top right.
3. The name of the new workflow is currently **"Untitled"**. Rename it to a more suitable title.
4. Select **"In-App"** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added In-App channel and configure it according to your preferences. Once you’re done, click Update to save your configuration.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.

In our case, we'll use the custom variables functionality, as shown below:

<Frame>
  <img />
</Frame>

Feel free to add only text for now and rename the workflow to quickstart. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

Having created a workflow and having our `subscriberID`, we're ready to send notifications using Novu!

## Using Novu in a vanilla JS app

We have already used the CDN to get the notification center component and we already have all the credentials that we need. To use it in an app, simply use the `notification-center-component` in your html file as shown below.

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    ...
    <!-- CDN link for Novu notification center component -->
    <script src="​https://web-component.novu.co/index.js"></script>
  </head>
  <body>
    <notification-center-component
      style="display: inline-flex"
      application-identifier="<YOUR_APPLICATION_IDENTIFIER>"
      subscriber-id="<YOUR_SUBSCRIBER_ID>"
    ></notification-center-component>

    <script>
      // here you can attach any callbacks, interact with the web component API
      // You can also move this to a separate js file and have all the callbacks and other logic there
      let nc =document.getElementsByTagName('notification-center-component')[0];
      nc.onLoad = () => console.log('hello world!');
    </script>
  </body>
</html>
```

You can add all the logic you want to add to the `script` element at the bottom or move it all into a separate JavaScript file (don't forger to link to the JavaScript file in this case).

Here's an example of such an HTML file:

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <script src="​https://web-component.novu.co/index.js"></script>

    <title>Vanilla JS app</title>
  </head>

  <body>
    <div>
      <h1>Notification generator</h1>
      <notification-center-component
        style="display: inline-flex"
        application-identifier="<YOUR_NOVU_APPLICATION_IDENTIFIER>"
        subscriber-id="123"
      ></notification-center-component>
    </div>
    <div class="">
      <form action="#" method="post" class="form">
        <input class="input" placeholder="Enter notification text" type="text" name="description" />
        <button class="btn">Send</button>
      </form>
    </div>
  </body>
  <script src="./app.js"></script>
</html>
```

And the corresponding script file is as follows:

```jsx theme={null}
const btn =document.querySelector('.btn');
const input =document.querySelector('.input');
const form =document.querySelector('.form');

const onClickHandler = async (e) => {
  e.preventDefault();
  const desc = input.value;
  console.log(desc);
  try {
    const resp = await fetch('<The API route from your backend>', {
      method: 'POST',
      body: JSON.stringify({
        description: desc,
      }),
      headers: {
        'Content-Type': 'application/json',
      },
    });
    input.value = '';
    console.log(resp);
  } catch (err) {
    console.log(err);
  }
};

form.addEventListener('submit', onClickHandler);

// here you can attach any callbacks, interact with the web component API
let nc =document.getElementsByTagName('notification-center-component')[0];
nc.onLoad = () => console.log('hello world!');
```

The front-end as well as the back-end code for the sample application can be found [here](https://github.com/novuhq/vanillajs-quickstart) for illustration.

## Code to trigger the notification

We can trigger a notification by simply executing the trigger code snippet we get from the Novu web dashboard.

To get the snippet:

1. Go to **Workflows** in the left sidebar on Novu web dashboard.
2. Select the workflow.
3. Click the **Get Snippet** button on the top right.

Here's the trigger snippet you'll receive:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<API_KEY>');

novu.trigger('quickstart', {
  to: {
    subscriberId: '<REPLACE_WITH_DATA>',
  },
  payload: {
    description: '<REPLACE_WITH_DATA>',
  },
});
```

> Make sure you're executing this code with the correct credentials.

## Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, configured a channel provider and triggered a notification in your React application.


# Vue
Source: https://v0.x-docs.novu.co/quickstarts/vue

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Vue.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications and integrate a rich, customizable and ready-to-use realtime UI In-App notification center in Vue apps.

# Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-vue) if you don’t have one yet.
* A working Vue development environment with a Vue 3 version.

You can also [view the completed code](https://github.com/novuhq/vue-quickstart) of this quick start in a GitHub repo.

# Create a new Vue app

If you already have a working Vue app, please feel free to skip this section.

Create a new Vue 3 app by running the following command in your terminal:

```bash theme={null}
npx create-vue notifications-app
```

Interactively run through the questions and answer them according to your preference. Then `cd` into the `notifications-app` folder and run the following:

```bash theme={null}
npm install && npm run format && npm run dev
```

# Install Novu Vue Notification Center Package

The Novu Vue package provides a Vue component wrapper over the web component that you can use to integrate the notification center into your Vue application.

Now install the Vue Notification Center package by running the following command in your terminal:

```bash theme={null}
npm install @novu/notification-center-vue
```

## Register The Notification Center Plugin

First, register the notification center plugin in your app as a global component.

In your `main.js` or `main.ts` file, add it like so:

```tsx theme={null}
import { createApp } from 'vue';

import NotificationCenterPlugin from '@novu/notification-center-vue';
import '@novu/notification-center-vue/dist/style.css';

// your app component
import App from './App.vue';

const app = createApp(App);

app.use(NotificationCenterPlugin);
app.mount('#app');
```

# Use The Notification Center Component

Create a new file, `NotificationCenter.vue` in the `src/components` directory. This file will house the Notification Center component.

Add the `NotificationCenterComponent` like so:

***Using the Composition API***

```tsx theme={null}
<script lang="ts" setup>
    const subscriberId = 'INSERT_SUBSCRIBER_ID_HERE'
    const applicationIdentifier = import.meta.env.NOVU_APP_IDENTIFIER
    const sessionLoaded = () => {
        console.log("Notification Center session loaded successfully!")
    }
</script>

<template>
    <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>
```

src/components/NotificationCenter.vue

***Using the Options API***

```tsx theme={null}
<script lang="ts">
export default {
  data() {
    return {
      applicationIdentifier: import.meta.env.VITE_NOVU_APP_IDENTIFIER,
      subscriberId: 'INSERT_SUBSCRIBER_ID_HERE',
    };
  },
  methods: {
    sessionLoaded() {
      console.log('Session loaded!')
    },
  },
};
</script>

<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>
```

src/components/NotificationCenter.vue

The `subscriberId` ideally should be the `id` of the **logged in user**. When a user logs into your app, they’ll be able to see all their notifications in the notification center. For this to work successfully, the user should have been created as a subscriber on Novu.

The `applicationIdentifier` is a public key used to identify your application. Obtain it from your [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-vue), and add it to your `.env` file.

If there’s none, create a `.env` file and add it like so:

```
VITE_NOVU_APP_IDENTIFIER = YOUR_NOVU_APP_IDENTIFIER;
```

Replace `YOUR_NOVU_APP_IDENTIFIER` with the real value from your dashboard.

# Display The In-App Notification Center UI

If you started by creating a new Vue app, then do the following:

Head over to `src/views/HomeView.vue` and import the `NotificationCenter.vue` component.

Replace the entire file with the code below:

```tsx theme={null}
<script setup lang="ts">
import NotificationCenter from '../components/NotificationCenter.vue'
</script>

<template>
  <main>
    <NotificationCenter />
  </main>
</template>
```

src/views/HomeView\.vue

Run your app again. You will see a button with the text **Notifications: 0**. Click on the button to reveal the notification center UI. Voila!

<Note>
  There are no notifications because none has been triggered yet. When notifications are sent to a subscriber, it will show up in the UI. Next, we'll learn how to trigger notifications.
</Note>

There’s a probability you might want the general notification bell icon. By default, the component displays the bell icon.

Simply delete the button element. Your component should look like this:

```jsx theme={null}
<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
  </NotificationCenterComponent>
</template>
```

You should now see a **bell button** that opens the notification center when clicked. This bell can be customized to your preference, and we will style and modify it in a later step.

* [Vue Notification Center Example Repo](https://github.com/novuhq/examples/tree/main/vue-notification-center-example)

# Create A Workflow

The first step to trigger notifications is to create a workflow. A workflow is like a map that holds the entire flow of messages sent to the subscriber.

<Note>
  The recipients of a triggered notification are called subscribers.
</Note>

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added In-App channel and configure it according to your preferences. Once you’re done, click Update to save your configuration.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).

Feel free to add only text for now and rename the workflow to `Onboarding In App`. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Next, we’ll learn how to create subscribers on Novu - *Recipients of Notifications*

# Create A Subscriber

Click **Subscribers** on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-vue) to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu.

Novu has a plethora of backend SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin) to choose from to create a subscriber programmatically. This is the recommended method.

Obtain your API key from your [Novu dashboard.](https://web.novu.co/settings?utm_campaign=docs-quick-vue) Replace `<NOVU_API_KEY>` with it.

Now check your Novu dashboard. You should see the recently created subscriber.

You can also update the subscriber info like so:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('132', {
  email: 'janedoe@domain.com', // new email
  phone: '+19874567832', // new phone
});
```

# Trigger A Notification

To trigger a notification, simply run the codesandbox below with the correct credentials.

```jsx theme={null}
// code to trigger a notification
```

`onboarding-in-app` is the workflow identifier we created earlier.

Ensure the `subscriberId` value in the backend code that triggers the notification matches the `subscriberId` in your **NotificationCenterComponent** code.

```tsx theme={null}
<template>
    <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>

<script lang="ts" setup>
    const subscriberId = '132'
    const applicationIdentifier = import.meta.env.NOVU_APP_IDENTIFIER
    const sessionLoaded = () => {
        console.log("Notification Center session loaded successfully!")
    }
</script>
```

Check your app again. You should see the recently triggered notification!

# Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, configured a channel provider and triggered a notification in your Vue application.


# Preferences
Source: https://v0.x-docs.novu.co/subscribers/preferences



Novu provides a way to store user preferences in the subscribers data model.
This allows subscribers to specify and manage their preferences, without your intervention. Customizing preferences has become the standard expected behavior for people and Novu can take the technical burden of managing preferences off of you.

**Novu allows several levels of preferences:**

* Workflow level channel preferences
* Subscriber level channel preferences
* Global level channel preferences

## Workflow level channel preferences

When creating a new workflow on the Web platform, you can specify default preferences for the subscribers in channel settings. They will be used unless the subscriber overrides them by his own custom preference.

This will allow you to create sensible defaults but still provide the user with the ability to override them. Template level preference can be managed in channel settings. All channels are `ON` unless specified otherwise.

`Workflow Settings > Channels`

<img />

## Subscriber level channel preferences

Our notification center component will show a user the available preferences, user will be able to modify on the channel level. Critical workflows will be excluded from the list. Click on cog (setting) icon on notification center component to open subscriber channel preferences page.

<img />

<Note>
  Only channels with a matched step will be returned from the API in
  notification center preference page. In case no channel content was found, the
  API will return an empty array.
</Note>

## Global level channel preferences

<Info>Since v0.20.0</Info>

Subscribers can set global channel preferences, which override individual settings. For instance, if there are 10 workflows, and a subscriber wants to disable SMS notifications for all of them, they can do so with a single global preference.

### Get subscriber global preference

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.getGlobalPreference("subscriberId" );
    ```
  </Tab>
</Tabs>

[Get subscriber's global preference API](/api-reference/subscribers/get-subscriber-global-preferences)

### Update subscriber global preference

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    // enable in-app channel and disable email channel
    await novu.subscribers.updateGlobalPreference("subscriberId", {
      enabled: true,
      preferences: [{
        type: "in_app"
        enabled: true
      }, {
        type: "email"
        enabled: false
      }]
    });
    ```
  </Tab>
</Tabs>

[Update subscriber's global preference API](/api-reference/subscribers/update-subscriber-global-preference)

<Note>Global subscriber preference can be updated and accessed using API and SDK only. Currently we have not added support of global subscriber preference in UI.</Note>

## Exclude workflows from preferences (critical workflow)

In some cases, you don't want the subscriber to be able to unsubscribe from mandatory notifications such as Account Verification, Password Reset, etc...

In those cases you can turn off the toggle `Users will be able to manage subscriptions` in channel settings. Workflow will become `critical`, once this toggle is turned `OFF`. By default, every workflow is `non-critical` and subscribers can manage channel preferences irrespective of workflow-level channel preferences. Critical workflow will not show on the subscriber preferences page.

## Get subscriber preferences

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from "@novu/node";

    const novu = new Novu("<NOVU_API_KEY>");

    // 111 is subscriberId
    await novu.subscribers.getPreference("111");
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    // 111 is subscriberId
    $novu->getSubscriberPreferences('111')->toArray();
    ```
  </Tab>
</Tabs>

## Get subscriber preference by level

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu, PreferenceLevelEnum } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');
    // Get global level preference
    await novu.subscribers.getPreferenceByLevel("subscriberId", PreferenceLevelEnum.GLOBAL)

    // Get template level preference
    await novu.subscribers.getPreferenceByLevel("subscriberId", PreferenceLevelEnum.TEMPLATE);
    ```
  </Tab>
</Tabs>

## Update subscriber preference for a workflow

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu, ChannelTypeEnum } from "@novu/node";

    const novu = new Novu("<NOVU_API_KEY>");

    // enable in_app channel
    await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
      enabled: true,
      channel: { type: ChannelTypeEnum.IN_APP, enabled: true },
    });

    // enable email channel
    await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
      enabled: true,
      channel: { type: ChannelTypeEnum.EMAIL, enabled: true },
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    // enable in_app channel
    $novu->updateSubscriberPreference('subscriberId', 'workflowIdentfier', [
        'enabled' => true
        'channel' => [
          'type' => 'in_app',
          'enabled' => true
        ]
    ]);

    // enable email channel
    $novu->updateSubscriberPreference('subscriberId', 'workflowIdentfier', [
        'enabled' => true
        'channel' => [
          'type' => 'email',
          'enabled' => true
        ]
    ]);
    ```
  </Tab>
</Tabs>

## Order of priority of preferences

1. if `Users will be able to manage subscriptions` toggle is turned off i.e workflow is critical, this will override workflow level and subscriber level preferences and notification will always be sent.
2. if workflow is non critical and subscriber has `false` value set for `enabled` field in preference then all other channels will become inactive even if they have `true` state.
3. if workflow is non critical and subscriber has `true` value set for `enabled` field in preference then notification will be filtered based on subscriber channel preference.
4. Workflow level channel preferences will be applied to all subscribers by default unless subscriber overrides them.

`Example`

1. For `First Workflow`, `critical` is false, `enabled` is true, in\_app, email, push channels are true and sms, chat channels are false. As per above order of priority of preferences, notification will be filtered as per the subscriber preferences. The subscriber will receive in-app, email and push notifications, but not receive sms and chat notifications.

2. For `Second Workflow`, `critical` is false, `enabled` is false, all channels are true. As per above order of priority of preferences, subscriber will not receive any type of notification because all channels become disabled due to false value of `enabled` field.

3. For `Third Workflow`. `critical` is true, `enabled` is false, email, chat channels are false and the other three channels are true. As per above order of priority of preferences, subscriber will receive all type of notifications as this workflow is `critical`.

<Tabs>
  <Tab title="First Workflow">
    ```json theme={null}
    {
      "template": {
        "_id": "firstWorkflowIdentifier",
        "name": "First Workflow",
        "critical": false
      },
      "preference": {
        "enabled": true,
        "channels": {
          "in_app": true,
          "email": true,
          "sms": false,
          "push": true,
          "chat": false
        }
      }
    }
    ```
  </Tab>

  <Tab title="Second Workflow">
    ```json theme={null}
    {
      "template": {
        "_id": "secondWorkflowIdentifier",
        "name": "Second Workflow",
        "critical": false
      },
      "preference": {
        "enabled": false,
        "channels": {
          "in_app": true,
          "email": true,
          "sms": true,
          "push": true,
          "chat": true
        }
      }
    }
    ```
  </Tab>

  <Tab title="Third Workflow">
    ```json theme={null}
    {
      "template": {
        "_id": "thirdWorkflowIdentifier",
        "name": "Third Workflow",
        "critical": true
      },
      "preference": {
        "enabled": false,
        "channels": {
          "in_app": true,
          "email": false,
          "sms": true,
          "push": true,
          "chat": false
        }
      }
    }
    ```
  </Tab>
</Tabs>

## API

<CardGroup>
  <Card title="Get subscriber preferences API" icon="plug" href="/api-reference/subscribers/get-subscriber-preferences" />

  <Card title="Update subscriber preference for a workflow API" icon="plug" href="/api-reference/subscribers/update-subscriber-preference" />

  <Card title="Update workflow API" icon="plug" href="/api-reference/workflows/update-workflow" />
</CardGroup>

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="How to change enabled field from UI?">
    This field can only be changed using API.
  </Accordion>

  <Accordion title="What preferences are applied to a subscriber when we create a new workflow?">
    In the case of a new workflow, the subscriber will inherit all preferences
    from the workflow\.However, after subsequent preference updates, the
    subscriber's preferences will not inherit workflow-level preferences.
  </Accordion>

  <Accordion title="How to disable a workflow for a single subscriber?">
    You can turn off all workflow's channels for a subscriber using [subscriber preference](/subscribers/preferences#subscriber-level-channel-preferences). If all channels are off, then the subscriber will not receive any message from any channel step and hence workflow is disabled for that subscriber
  </Accordion>
</AccordionGroup>


# Subscribers
Source: https://v0.x-docs.novu.co/subscribers/subscribers



In Novu, we call the entities designed to receive notifications as `Subscribers`. Each subscriber is unique and identified by a unique subscriberId.

<Note>
  `subscriberId` is a unique identifier used by Novu to keep track of a specific subscriber.
  We recommend using the internal unique id your application uses for a specific user.
</Note>

Each subscriber has the following data points:

* **User Data** - Data stored in the subscriber object that you can easily access in your notification templates. This contains basic info such as first name, last name, avatar, locale, email, and phone. This data is fixed and structured.
* **Custom Data** - Apart from the above fixed structured user data, any unstructured custom data such as user's address, nationality, height, etc can also be stored in the `data` field using key-value pairs.
* **Channel Specific Credentials** - `deviceTokens` required to send push notifications and `webhookUrl` for chat channel providers can also be stored.

## Subscriber attributes

| Field        | Type   | Required | Example                                                                        |
| :----------- | :----- | :------- | :----------------------------------------------------------------------------- |
| subscriberId | string | true     | b0bea066-f5fe-11ed-b67e-0242ac120002                                           |
| firstName    | string | false    | John                                                                           |
| lastName     | string | false    | Doe                                                                            |
| email        | string | false    | [john.doe@domain.org](mailto:john.doe@domain.org).                             |
| phone        | string | false    | +13603963366                                                                   |
| locale       | string | false    | en                                                                             |
| avatar       | string | false    | [https://example.com/images/avatar.jpg](https://example.com/images/avatar.jpg) |
| data         | object | false    | `{"key": "value"}`                                                             |

## Subscriber response schema

**Novu subscriber object**

```json theme={null}
{
  "_id": "NOVU_GENERATED_SUBSCRIBER_ID",
  "_organizationId": "NOVU_GENERATED_ORG_ID",
  "_environmentId": "NOVU_GENERATED_ENV_ID",
  "firstName": "John",
  "lastName": "Doe",
  "subscriberId": "subscriberId",
  "email": "[john.doe@org.com](mailto:john.doe@org.com)",
  "phone": "+98712345670"
  "data": {
    "custome_key_1" : "custom_value_1",
    "custome_key_2" : "custom_value_2"
  }
  "channels": [
  {
    "credentials": {
      "deviceTokens": [
        "token1",
        "token2"
      ]
    },
    "_integrationId": "NOVU_GENERATED_INTEGRATION_ID",
    "providerId": "fcm"
  },
  {
    "credentials": {
      "webhookUrl": "URL"
    },
    "_integrationId": "NOVU_GENERATED_INTEGRATION_ID",
    "providerId": "discord"
  }
  ],
  "deleted": false,
  "createdAt": "2022-10-13T17:40:53.231Z",
  "updatedAt": "2022-10-13T17:41:53.238Z",
  "__v": 0,
  "isOnline": false,
  "lastOnlineAt": "2022-10-13T17:41:53.238Z",
  "avatar": "AVATAR_URL",
  "id": "NOVU_GENERATED_SUBSCRIBER_ID"
}
```

## Create a subscriber

You can create a subscriber in Novu using the `identify` method provided in Novu's SDK.

<Tip>The `identify` method serves the purpose of handling existing "subscriberId" providers within the database.
When a provider with the same subscriberId already exists, this method performs an update operation using the data present in the payload.
In cases where there is no pre-existing entry, the method generates a new one, thus exhibiting an <Tooltip>upsert</Tooltip>
behavior.</Tip>

<Note>
  It is possible for two subscribers to have the same email address in our system. This is because the `subscriberId` is the unique identifier that distinguishes one subscriber from another.
</Note>

```jsx theme={null}
import { Novu } from "@novu/node";

// Insert your Novu API Key here
const novu = new Novu("<NOVU_API_KEY>");

// Create a subscriber on Novu
await novu.subscribers.identify("132", {
  email: "john.doe@domain.com",
  firstName: "John",
  lastName: "Doe",
  phone: "+13603963366",
});
```

<Warning> The `phone` parameter must be parsed as a string.</Warning>

You should now be able to see your new subscriber on the Novu dashboard.

You can also add additional fields such as `phone`, `avatar`, and `data`.

<Note> Remember, all user IDs added to Novu need to be unique. </Note>

If you face issues with the subscriber creation only taking the user ID and omitting other fields such as firstName, lastName, etc., you could consider updating the subscriber after creation.

Please also be aware that although it's currently possible to create a subscriber with an empty `subscriberId`, this subscriber cannot be deleted later.

We support creating new subscriber using two ways, `Ahead of Trigger` means adding subscribers before triggering notification or `Inline of Trigger` means sending complete subscriber data in `to` field while triggering.

### 1. Ahead of Trigger

Create the subscriber and then trigger the notification to this subscriber. Here `subscriberId` is the required field and other fields are optional.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.identify('111', {
      email: 'john.doe@domain.com',
      firstName: 'John',
      lastName: 'Doe',
      phone: '+13603963366',
      avatar: 'https://example.com/images/avatar.jpg',
      locale: 'en-US',
      data: { customKey1: 'customVal1', customKey2: 'customVal2' },
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->createSubscriber([
        'subscriberId' => '111',
        'email' => 'john.doe@domain.com',
        'firstName' => 'John',
        'lastName' => 'Doe',
        'phone' => '+13603963366',
        'avatar' => 'https://example.com/images/avatar.jpg',
        'locale' => 'en',
        'data' => [
          'customKey1' => 'customVal1',
          'customKey2' => 'customVal2'
        ]
    ]);
    ```
  </Tab>
</Tabs>

Novu will create a subscriber if one does not exist and will update the existing subscriber based on the `identify` payload. You can call this function during registration or signup to make sure the subscriber data is up-to-date, if you wish to save additional attributes with a subscriber, you can pass additional custom data in the **data** field as key-value pairs.

### 2. Inline of Trigger

A non-existing subscriber can be added by sending subscriber data in `to` field of the trigger method. If any subscriber with provided `subscriberId` does not exists, a new subscriber will be created. In this case, subscriber will be created first and then the trigger will be executed synchronously.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '111',
        email: 'john.doe@domain.com',
        firstName: 'John',
        lastName: 'Doe',
        phone: '+13603963366',
      },
      payload: {
        customVariable: 'variableValue',
        organization: {
          logo: 'https://organization.com/logo.png',
        },
      },
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->triggerEvent([
      'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
      'to' => [
          'subscriberId' => '111',
          'email' => 'john.doe@domain.com',
          'firstName' => 'John',
          'lastName'  => 'Doe',
          'phone' => '+13603963366'
      ]
      'payload' => [
          'customVariable' => 'variableValue',
          'organization' => [
            'logo' => 'https://organization.com/logo.png',
          ]
        ],
    ]);
    ```
  </Tab>
</Tabs>

## Bulk Subscriber Creation

You can create subscribers in bulk *(up to 500 at once)* via the SDKs or [API](/api-reference/subscribers/bulk-create-subscribers).

<Note> The bulk subscriber creation feature is only available in v0.19.0 and above.</Note>

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    await novu.subscribers.bulkCreate([
      {
        subscriberId: 'test-subscriber-1',
        email: 'test-user@sd.com',
        firstName: 'subscriber-1',
        lastName: 'test-1',
      },
      {
        subscriberId: 'test-subscriber-2',
        email: 'test-user-2@sd.com',
        firstName: 'subscriber-2',
        lastName: 'test-2',
      },
      {
        subscriberId: 'test-subscriber-3',
      },
    ]);
    ```
  </Tab>
</Tabs>

## Import subscribers

Here, `mock_data.csv` file is a CSV file having mock data. The below script will read this CSV file and create a new subscriber in Novu. Change example variables values like `API_KEY` value with your valid values. Download `mock_data.csv` file from [here](https://drive.google.com/file/d/159Upw30ZcPa_QnzlKF-C6_dHKDJeU-TW/view).

<Note> `mock_data.csv` file should be in the same directory of script </Note>

Steps:

1. Export your user details in CSV format.
2. Clean this exported CSV file. Keep only relevant fields.
3. Move this CSV file to the script directory.
4. Change the file name in the script with your file name.
5. Run the script. (Make script.sh executable before using)

<Tabs>
  <Tab title="Shell">
    ```shell theme={null}
    #!/bin/bash

    # Change these variables with your own values
    CSV_FILE="mock_data.csv"
    API_ENDPOINT="https://api.novu.co/v1/subscribers"
    API_KEY="ApiKey <API_KEY>"

    OLDIFS=$IFS
    IFS=','
    [ ! -f $CSV_FILE ] && { echo "$CSV_FILE file not found"; exit 99; }

    SECONDS=0

    # Read the CSV file line by line
    while read subscriberId firstName lastName email phone locale avatar
    do
        # Check if subscriberId is empty or not present
        if [[ -z "$subscriberId" ]]; then
            echo "Skipping row with missing subscriberId"
            continue
        fi

        # Construct the JSON body for the POST request
        json_body="{\"subscriberId\": \"$subscriberId\""

        # Add optional fields to the JSON body if present
        if [[ -n "$firstName" ]]; then
            json_body="$json_body, \"firstName\": \"$firstName\""
        fi

        if [[ -n "$lastName" ]]; then
            json_body="$json_body, \"lastName\": \"$lastName\""
        fi

        if [[ -n "$email" ]]; then
            # Validate email using regex
            if [[ ! "$email" =~ ^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$ ]]; then
                echo "Invalid email format for subscriberId: $subscriberId"
                continue
            fi
            json_body="$json_body, \"email\": \"$email\""
        fi

        if [[ -n "$phone" ]]; then
            json_body="$json_body, \"phone\": \"$phone\""
        fi

        if [[ -n "$locale" ]]; then
            # Validate locale using regex
            if [[ ! "$locale" =~ ^[a-zA-Z]{2}(-[a-zA-Z]{2})?$ ]]; then
                echo "Invalid locale format for subscriberId: $subscriberId"
                continue
            fi
            json_body="$json_body, \"locale\": \"$locale\""
        fi

        if [[ -n "$avatar" ]]; then
            json_body="$json_body, \"avatar\": \"$avatar\""
        fi

        if [[ -n "$address" || -n "$job" ]]; then
            json_body="$json_body, \"data\": {"

            if [[ -n "$address" ]]; then
                json_body="$json_body \"address\": \"$address\""
            else
                json_body="$json_body \"address\": \"\""
            fi

            if [[ -n "$job" ]]; then
                json_body="$json_body, \"job\": \"$job\""
            else
                json_body="$json_body, \"job\": \"\""
            fi

            json_body="$json_body }"
        fi

        json_body="$json_body}"

        echo $json_body

        #Send the cURL POST request with the JSON body and handle exceptions
        response=$(curl -s -X POST -H "Content-Type: application/json" -H "Authorization: $API_KEY" -d "$json_body" -w "%{http_code}" "$API_ENDPOINT")

        http_code=${response:${#response}-3}

        if [[ $http_code -eq 201 ]]; then
            echo "cURL request successful for subscriberId: $subscriberId - HTTP Status Code: $http_code"
        else
            echo "cURL request failed for subscriberId: $subscriberId - HTTP Status Code: $http_code - response : $response"
        fi

    done < "$CSV_FILE"

    ELAPSED="Time Elapsed: $(($SECONDS / 3600))hrs $((($SECONDS / 60) % 60))min $(($SECONDS % 60))sec"

    echo $ELAPSED
    ```
  </Tab>

  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';
    require('dotenv').config();

    const csv = require('csv-parser');
    const fs = require('fs');

    const novu = new Novu('<NOVU_API_KEY>');

    fs.createReadStream('mock_data.csv')
      .pipe(csv())
      .on('data', async (data) => {
        let subscriber = await novu.subscribers.identify(data.subscriberId, {
          email: data.email,
          firstName: data.firstName,
          lastName: data.lastName,
          phone: data.phone,
          avatar: data.avatar,
          locale: data.locale,
          data: { address: data.address, job: data.job },
        });

        console.log(subscriber.data);
      })
      .on('end', () => {
        console.log('done');
      });
    ```
  </Tab>
</Tabs>

## Delete a subscriber

To stop a subscriber from receiving notifications, you can delete the subscriber. This will hard delete the subscriber and means you will not be able to access this subscriber later. You will have to create this subscriber again.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.delete('111');
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->deleteSubscriber('111');
    ```
  </Tab>
</Tabs>

## Update a subscriber

In some cases, you want to access a subscriber to update a specific user data field or custom data field. For example, when the users change their email address or personal details.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.update('111', {
      // new email
      email: 'john@domain.com',
      // new phone
      phone: '+19874567832',
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->updateSubscriber('111', [
        // new email
        'email' => 'john@domain.com',
        // new phone
        'phone' => '+19874567832',
    ])->toArray();
    ```
  </Tab>
</Tabs>

## Find a subscriber

Any subscriber can be retrieved using a unique subscriber identifier `subscriberId`. Check the returned subscriber schema [here](#subscriber-response-schema).

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.get('111');
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->getSubscriber('111')->toArray();
    ```
  </Tab>
</Tabs>


# Topics
Source: https://v0.x-docs.novu.co/subscribers/topics



Novu offers a simple API providing an easy interface for triggering notifications to multiple subscribers at once. It is called Topics and allows the users to manage their bulk notifications without having to do complex loop implementations. A topic is identified by a custom key that is provided by the user. This custom key will be the identifier for the topic.

<Warning>
  The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.
</Warning>

Users can also assign a name to a topic. This name doesn't need to be unique and it can be changed using the API. So far, it is for descriptive goals.

A topic would get assigned different subscribers that will receive a notification every time a notification is sent to the topic.

## Create A Topic

In order to be able to send a notification to a topic, first the user needs to create one. It can be done like this:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const result = await novu.topics.create({
  key: 'unique-topic-identifier',
  name: 'descriptive-topic-name',
});
```

If successful this will return the internal Id generated by Novu and the topic key given by the user.

That topic key can be used to retrieve the whole Topic entity:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const key = 'unique-topic-identifier';

const result = await novu.topics.get(key);
```

## Rename a Topic

Descriptive name given during creation of topic can be changed later. This can be done like this:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const topicKey = 'posts:comment:12345';
const topicName = 'Post Comments';

const result = await novu.topics.rename(topicKey, topicName);
```

This will return the whole Topic information, including the subscribers if having any.

<Note>Topic Key can not be changed</Note>

## Add subscribers to a Topic

Adding subscribers to the topic is the main usecase of topic. A topic is like a group of subscribers. A notification can be sent to all subscribers of a topic at once

<Warning>
  Before adding subscribers to a topic, it's crucial to ensure that they are correctly identified in the Novu system. This identification is done using the [identify method](/subscribers/subscribers#create-a-subscriber) or API. When a subscriber is added to a topic, Novu uses the identification information to pick up the email or phone number associated with the subscriber.
</Warning>

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const topicKey = 'posts:comment:12345';

const response = await novu.topics.addSubscribers(topicKey, {
  subscribers: ['subscriber-id-1', 'subscriber-id-2', ...],
});
```

This call will return a response in the shape of:

```typescript theme={null}
{
    succeeded: ['subscriber-id-1', 'subscriber-id-2', ...],
    failed: {
      notFound: ['subscriber-id-1', 'subscriber-id-2', ...],
    },
}
```

The field `succeeded` will return the array of subscriber ids that have been correctly assigned to the topic. The field `failed` will show up only if there has been any subscriber that couldn't been assigned to the topic. This probably will happen if there is any typo in the given subscriberId or if the given subscriberId doesn't belong to the environment and the organization where the topic has been created.

### Create topic on the fly

To facilitate flows we allow to create a topic on the fly when adding subscribers.

If the topic key used does not exist for the selected environment and organization, Novu will create a new topic with name `Autogenerated-<TOPIC_KEY>` and the subscribers will be assigned to this newly created topic.

After that, that topic created on the fly can be managed in the same ways as the ones created in the normal way.

## Verify if subscriberId belongs to a topic

There would be times when it would be needed to verify if a certain subscriber belongs to a topic in order to decide what to do with that subscriber. The API call to achieve that is the following:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const externalSubscriberId = 'external-subscriber-id-1';
const topicKey = 'posts:comment:12345';

const response = await novu.topics.getSubscriber(topicKey, externalSubscriberId);
```

<Note>
  The subscriberId to use in this API call is the one used as subscriber identifier.
  The choice was made to make easier for the user to use this without making extra calls to Novu.
</Note>

## Remove a subscriber from a Topic

A single or group of subscribers can be removed from an existing topic.

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const topicKey = 'posts:comment:12345';

const response = await novu.topics.removeSubscribers(topicKey, {
  subscribers: ['subscriber-id-1', 'subscriber-id-2', ...],
});
```

Where `subscribers` will be an array of the subscriberIds we want to remove from the topic. If successful an empty response will be returned.

## Delete a topic

An existing topic can be deleted using topic-key as topic-key is the unique identifier for a topic.

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const key = 'unique-topic-identifier';

const result = await novu.topics.delete(key);
```

<Warning>
  A topic can only be deleted if it doesn't have any subscriber added. When trying to delete a topic with subscribers a conflict error will be returned. This is done to prevent accidental topic deletions.
</Warning>

## Trigger workflow to a topic

A workflow can be triggered to a single subscriber and an array of subscribers. While doing so, one need to send subscriberIds in `to` field. In case of trigger, we have already stored subscriberIds in a topic, so a topic key can be used to trigger a workflow. Workflow will be triggered to all subscribers in the topic.

```typescript theme={null}
const topicKey = 'posts:comment:12345';

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: [{ type: 'Topic', topicKey: topicKey }],
  payload: {},
});
```

## Trigger workflow to multiple topics

Workflow can be triggered to multiple subscribers by using an array of topics.

```typescript theme={null}
const topicKey = '<TOPIC-KEY-DEFINED-BY-THE-USER>';

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: [
    { type: 'Topic', topicKey: topicKey },
    { type: 'Topic', topicKey: 'Another Topic Key' },
  ],
  payload: {},
});
```

## Exclude actor from topic trigger event

To exclude the actor responsible for the action of a triggered topic event, you must add the subscriberId of that actor when triggering that event.

```typescript theme={null}
const topicKey = 'posts:comment:12345';

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: [{ type: 'Topic', topicKey: topicKey }],
  payload: {},
  actor: { subscriberId: '<SUBSCRIBER_ID_OF_ACTOR>' },
});
```

## Usecase Example

User X makes a comment, other users (A, B) who've already commented before should get a notification. So, when triggering the notification on that topic, you would usually want to exclude User X from receiving a notification about their own comment. To do that - you would need to add User X's subscriberId to the trigger event.

## API

<CardGroup>
  <Card title="Fetch list of topics" icon="plug" href="/api-reference/topics/filter-topics" />

  <Card title="Create a new topic" icon="plug" href="/api-reference/topics/topic-creation" />

  <Card title="Add subscribers to a topic" icon="plug" href="/api-reference/topics/subscribers-addition" />

  <Card title="Check if subscriber belongs to a topic" icon="plug" href="/api-reference/topics/check-topic-subscriber" />

  <Card title="Remove subscribers from a topic" icon="plug" href="/api-reference/topics/subscribers-removal" />

  <Card title="Fetch a topic by topic-key" icon="plug" href="/api-reference/topics/get-topic" />

  <Card title="Delete a topic" icon="plug" href="/api-reference/topics/delete-topic" />

  <Card title="Rename a topic" icon="plug" href=" /api-reference/topics/rename-a-topic" />
</CardGroup>

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="Does it mean that all subscribers of one topic have same preference">
    No, adding subscribers into topic does not change subscriber's individual [subscriber preference](/subscribers/preferences). Topic is mainly used to group subscribers and fan out workflow triggered notifications to all subscribers at once.
  </Accordion>
</AccordionGroup>


# Tenants
Source: https://v0.x-docs.novu.co/tenants/introduction

Learn all about Tenants

Multi-tenancy is a common use case for a lot of companies that have multiple organizations that use their applications. In some cases, there is a need to separate the behavior of the notification system depending on the individual tenants.

Currently, Novu supports the following customizations:

* Workflow level customizations
* Integration customizations

## Tenant Management

Tenants can be created and modified via the [API](http://docs.novu.co/api-reference/tenants/get-tenants) or [Web](https://web.novu.co/tenants?utm_campaign=docs-tenants). Each tenant can have multiple fields on it:

* Identifier - The identifier is a unique value, and can be used later when pointing to this tenant during trigger calls.
* Name - A human-readable name of the tenant.
* Data - A custom data object that can store information about the tenant. This data can be later accessed inside workflows.

To create a tenant on the Novu web platform, follow these steps:

* Click on `Tenants` on the left sidebar.
* In the Tenants section, click on the `Add a tenant` button.
* Set a `Name` and `Tenant identifier`. The tenant identifier is automatically set once you add a name. However, you can modify it to your needs.
* Set a JSON-format `Custom properties` (optional).

## Workflow Level Customizations

When triggering a workflow, it is possible to pass the tenant information (id or object, in case of an object, novu will upsert the tenant if it’s not existing) like so:

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
      import { Novu } from '@novu/node';

      const novu = new Novu("<NOVU_API_KEY>");

      await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
        {
          to: {
            subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          },
          payload: {
            name: "Hello World",
          },
          actor: "actorId"
          tenant: "tenantIdentifier"
        }
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
      use Novu\SDK\Novu;

      $novu = new Novu('<NOVU_API_KEY_HERE>');

      $novu->triggerEvent([
        'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
        'payload' => [
          'name' => 'Hello'
        ],
        'to' => [
            'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
        ],
        'actor': "actorId"
        'tenant': "tenantIdentifier"
      ]);
    ```
  </Tab>
</Tabs>

The tenant information can now be used inside the workflow template in the following way:

```
{{ tenant.data.customProp }}
```

## Workflow Settings Override

Workflow settings can now be updated on the workflow per tenant. This enables each tenant to have unique preferences that doesn't affect others within the same workflow.

The `active` and `channel` preferences fields of a workflow can be updated to be tenant-specific the [workflow-overrides API endpoint](/api-reference/workflow-overrides/create-workflow-overrides).

<Warning>This feature is only available from v0.22.0.</Warning>

## Integration Level Customizations

When creating an integration, you can create a condition where you can specify a delivery provider for a channel when a particular tenant id is matched.

The delivery provider specified will only be used if the trigger is executed with the tenant id.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Tenant-specific Notification Content

When creating a step, variants could be created for each step including digest and delay. For each variant, conditions set can be applied on when this variant could be used.

Using so different workflow configurations (for example digest duration) could be configured on the individual workflow for a given tenant.

For example, if you want a specific notification content to be sent to a tenant named "JohnDoe", and another to be sent to others. You can do the following:

* Create an email step in your workflow
* In the email step workflow, click on the "Add variant" icon at the top right to add a new variant.

<Frame>
  <img />
</Frame>

* It opens up the condition page. Set the tenant identifier to equal "JohnDoe".

<Frame>
  <img />
</Frame>

* Apply Conditions as shown above.
* Check the email step in the workflow, you'll see the **root variant** and **v1 variant**.

<Frame>
  <img />
</Frame>

Once a trigger runs, the Novu engine checks to see if there's a `tenant` identifier specified in the trigger code.

An example of the trigger code:

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
      import { Novu } from '@novu/node';

      const novu = new Novu("<NOVU_API_KEY>");

      await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
        {
          to: {
            subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          },
          tenant: "JohnDoe"
        }
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
      use Novu\SDK\Novu;

      $novu = new Novu('<NOVU_API_KEY_HERE>');

      $novu->triggerEvent([
        'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
        'to' => [
            'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
        ],
        'tenant': "JohnDoe"
      ]);
    ```
  </Tab>
</Tabs>

* If it exists, a condition check is done to see if there's a variant that matches the tenant identifier.
* If there's a match, the specific variant template will be fired.
* If there's no match, the root variant template will be fired.

It is also possible to use handlebars to have minor tenant adjustments in a single step:

```
<img src="{{tenant.data.logo}}" />
```

<Warning> For self-hosted users, this is only available from version 0.22.0. </Warning>


# Delay Action
Source: https://v0.x-docs.novu.co/workflows/delay-action

More on how Delay Action Node works

The delay action awaits a specified amount of time before moving on to trigger the following steps of the workflow.

### Delay Action Node

After adding a delay node in the workflow editor, the immediate next step will only be triggered after the specified period of time has elapsed.

# Configurations

## Regular Delay

Regular Delay will determine how long it will take before triggering the next step.

## Time Interval

You can specify the amount and time unit that best suits your needs.

Should you wish to, you could override the default delay time interval you set in the creation of the delay node.

```tsx theme={null}
novu.trigger('template-name', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>'
  },
  payload: {
    name: 'Hello',
  },
  overrides: {
    delay: {
      unit: 'days',
      amount: 2,
    },
  },
});
```

## Scheduled Delay

Scheduled Delay allows delaying up to a future date before continuation of steps execution. All steps after delay node will be triggered only after said date.

### Payload Path[](https://docs.novu.co/platform/delay#payload-path)

Payload path will determine the path in payload for the scheduled date.

That path must be included in your payload on trigger execution and must be a date in strict ISO format.

For example:

<img />

```tsx theme={null}
novu.trigger('workflow-name', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>'
  },
  payload: {
    sendAt: '2022-09-21T10:48:44.388Z',
  },
});
```

<Note>
  Date must be in ISO date format of YYYY-MM-DDThh:mm:ss.SSSZ
</Note>


# Digest Engine
Source: https://v0.x-docs.novu.co/workflows/digest

Deep dive into Digest functionality

The digest engine collects multiple trigger events, aggregates them into a single message and delivers it to the subscriber.

This becomes useful when a user needs to be notified on a large amount of triggers and you want to avoid sending too many notifications. Novu will automatically batch the incoming trigger events based on the `subscriberId` and an **optional** `digestKey` that can be added to control the digestion of the events.

### Digest Node

After adding a digest node in the workflow editor, each node that will be below the digest node will be only triggered once in the specified digest interval. You can decide to send messages before adding a digest node and they will be triggered in real-time.

<Frame>
  <img />
</Frame>

In the image above, there are two nodes (`Email` and `SMS`) after the digest node and one node (`In-App`) before the digest node in the workflow.

For this workflow, if we trigger 10 events within the digest interval, the `In-App` step will be executed 10 times, and `Email` and `SMS` will be executed only 1 time with digested events data.

## Digest Configuration

### 1. Digest Key

If specified, the digest engine will group the events based on the `digestKey` and `subscriberId`, otherwise the digest engine will group the events based only on the subscriberId.

The digest key might come useful when you want a particular subscriber to get events grouped on a custom field. For example when an actor likes the user's post, you might want to digest based on the `post_id` key.

<Frame>
  <img />
</Frame>

### 2. Time Interval

The time interval determines how long the digest engine will wait before sending the message once created. You can specify the amount and the unit that best suits your needs.

Here, in the image below, `5` is the interval amount, and `mins` is the interval unit. Interval units can be `sec(s)`, `min(s)`, `hour(s)`, or `day(s)`.

<Frame>
  <img />
</Frame>

## Digest Strategy Types

The strategy which Novu should use to handle the digest step. More details on available strategies below.

Novu allows you to define different digest strategies depending on the actual use-case you are trying to achieve. At this point we allow you to select from 2 strategies:

* Regular Strategy
* Back-off Strategy

Let's explore them in detail:

#### Regular Strategy

In regular strategy, a digest will always be created for the specified window time. Which means that from the first event trigger, if no active digest exists for this subscriber, one will be created and the user will receive the message only when the digest window time is reached.

#### Back-off Strategy

In the back-off strategy, before creating a digest, Novu will check if a message was sent to the user in the back-off period. If a message was sent, a digest will be created. Otherwise, a message will be sent directly to the user and the digest creation will be skipped.

Backoff digest has two intervals, `digest interval` and `backoff interval`. Here, in the image below, the `digest interval` is `20 minutes`, and the `backoff interval` is `15 minutes`. In the case of a backoff digest, first, it checks if any event is triggered within the past backoff interval, only then a digest is created for the digest interval. If not, the event is considered non-digest and workflow execution continues to the next step.

<Frame>
  <img />
</Frame>

**Example:**

Let's set the digest interval as 20 minutes and the backoff time as 15 minutes.

If we trigger the first event. Since it is the first event and there was no event triggered in the past 15 minutes (backoff interval), this event will be executed as it is (without digest).

Now, if we trigger a second within 15 minutes, then a new digest will be created with this second event. From now onwards till 20 minutes (digest interval), all triggers will be digested in this digest, and after 20 minutes, the workflow will carry forward to the next step with digested events.

## Scheduled Digest

**Minutes:**

It digests events for every specified minutes. For example, as per the image below, events will be digested for 20 minutes and after 20 minutes, workflow will carry forward to the next step. It will be repeated after every 20 minutes.

<Frame>
  <img />
</Frame>

**Hour:**

It digests events for given hours. After given hours, a new digest is created.

<Frame>
  <img />
</Frame>

**Daily:**

It digests events for specified days till given time. After those days and time, a new digest is created and events are digested in this new digest.

<Frame>
  <img />
</Frame>

**Weekly:**

It digests events for specified weekdays. Only at the specified time, the workflow continues to the next step after the digest step. A new digest is created and events are digested in this new digest till these weeks and time.

<Frame>
  <img />
</Frame>

**Monthly:**

<Frame>
  <img />
</Frame>

## Writing digest templates

In many cases, you will need to access all the digested events payload in order to show the user all or parts of the events included in this digest. For example: **"John and 5 others liked your photo."**

As part of the digested template, you will have access to a few properties:

| Property           | Description                                                                                                                                       |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| `step.events`      | An array of all the events aggregated under this digest. This will be the "payload" object passed to each trigger.event sent in the digest period |
| `step.total_count` | The number of total events in this digest                                                                                                         |
| `step.digest`      | A boolean flag to indicate if we are in a digest mode right now                                                                                   |

Let's look at a handlebars syntax example for the following triggers:

```tsx theme={null}
novu.trigger('workflow-name', {
  to: '123',
  payload: {
    name: 'Hello',
  },
});

novu.trigger('workflow-name', {
  to: '123',
  payload: {
    name: 'World',
  },
});
```

After these two triggers, digest variables are as follows:

| Property           | Description                                     |
| ------------------ | ----------------------------------------------- |
| `step.events`      | `[ { "name" : "Hello" }, { "name": "World" } ]` |
| `step.total_count` | `2`                                             |
| `step.digest`      | `true`                                          |

Using the following template:

```HTML theme={null}
Total events in digest:
{{step.total_count}}

{{#if step.digest}}
  {{#each step.events}}
    {{name}}
  {{/each}}
{{else}}
  Not a digested template
{{/if}}
```

It will render as:

`Total events in digest: 2 This is Hello payload event This is World payload event`

<Note> Note that if only one matching trigger activates a regular digest during its period, that single item will still come through as a digest with `step.total_count` as 1. </Note>

### Using subscriber variables

Subscriber variables like `{{subscriber.firstName}}` , `{{subscriber.email}}` etc are system reserved variables. These variables can be used in the same form if used outside of `step.events` iteration. If you want to use subscriber variables inside `step.events` iteration, you can use `{{../subscriber.firstName}}` , `{{../subscriber.email}}`. Reason of this change inside `step.events` iteration is the context change. Subscriber variables are available in the parent context of `step.events` iteration.

```HTML theme={null}
Total events in digest:
{{step.total_count}}
Hey, {{subscriber.firstName}} your id is {{subscriber.subscriberId}}
{{#if step.digest}}
  {{#each step.events}}
    {{name}}
    <br/>
    {{../subscriber.firstName}} your email is {{../subscriber.email}}
  {{/each}}
{{else}}
  Not a digested template
{{/if}}
```

## Event cancellation from Digest

Any event can be cancelled from the Digest via the [event cancellation API](/api-reference/events/cancel-triggered-event) using transactionId of triggered event. For example, if there are 5 events in digest, a user should be able to cancel the **2nd**, **3rd**, or **4th** event before digest time completion.

The cancelled event will not be included in the final digest events array.

## Digest Guides

<CardGroup>
  <Card title="Add Digest to Email Notifications" icon="envelope" href="/guides/add-digest-to-email-notifications">
    Learn how to add digest functionality to email notifications.
  </Card>

  <Card title="Add Digest to In-App Notifications" icon="bell" href="/guides/add-digest-to-inapp-notifications">
    Learn how to add digest functionality to a In-App feed within React app.
  </Card>
</CardGroup>

## Frequently Asked Questions

<Note>All digest times are in UTC time</Note>

<AccordionGroup>
  <Accordion title="If scheduled digest is set for 9:00 AM daily then will the digest be sent at 9:00 AM every day without any event triggered?">
    If scheduled digest is sent for 9:00 daily, then novu will collect all events triggered between 9:00 AM today till 9:00 AM tomorrow and send the digest at 9:00 AM tomorrow. This process is repeated daily. If there is no any event triggered between 9:00 AM today and 9:00 AM tomorrow, then no digest will be sent.
  </Accordion>

  <Accordion title="What is the difference between Regular and Schedules Digest set to 1 Hour?">
    Both digests are same in this case.
  </Accordion>
</AccordionGroup>


# Messages
Source: https://v0.x-docs.novu.co/workflows/messages

Learn about messages in Novu

Each [workflow](/workflows/notification-workflows) has one or more than one step. Each step is either a `channel` (in\_app, email, push, chat) or an `action` (digest, delay).

Within the workflow, every channel has a separate template. Email channel step content can be different than `in_app` channel step content. When a workflow is triggered, Novu generates separate messages for every channel step and sends that message to the recipient.

A triggered event (`notification`) is a collection of step information, its message, and job execution details.

## List messages

Messages can be listed using these SDK methods. These methods support pagination using page and limit field and filters using channel, subscriberId and transactionId field.

<Info>Novu will throw 404 error if requested subscriberId is not a valid subscriberId of any existing subscriber.</Info>

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu, ChannelTypeEnum } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.messages.list({
      page: 0,
      limit: 30,
      channel: ChannelTypeEnum.IN_APP,
      subscriberId: '<SUBSCRIBER_ID>'
      transactionIds: ['transactionId1', 'transactionId2'],
    });
    ```
  </Tab>
</Tabs>

### List messages example response

```javascript theme={null}
{
  "page": 0,
  "totalCount": 987,
  "hasMore": true,
  "pageSize": 30,
  "data": [
    ....
    {
      "cta": {
          "action": {
              "buttons": []
          },
          "type": "redirect",
          "data": {
              "url": ""
          }
      },
      "_id": "messageId",
      "_templateId": "workflowId",
      "_environmentId": "environmentId",
      "_messageTemplateId": "messageTemplateId",
      "_notificationId": "notificationId",
      "_organizationId": "organisationId",
      "_subscriberId": "_subscriberId",
      "_jobId": "jobId",
      "templateIdentifier": "workflowIdentifier",
      "_feedId": "feedId",
      "channel": "in_app",
      "content": "Message Content",
      "deviceTokens": [],
      "seen": false,
      "read": false,
      "status": "sent",
      "transactionId": "d5218a6c-4b08-4617-b176-2d2271f34e42",
      "payload": {
          "key": "value"
          "__source": "test-workflow"
      },
      "expireAt": "2024-06-17T08:18:29.871Z",
      "deleted": false,
      "createdAt": "2023-06-17T08:18:29.871Z",
      "updatedAt": "2023-06-17T08:24:34.888Z",
      "__v": 0,
      "subscriber": {
          "_id": "_subscriberId",
          "subscriberId": "subscriberId",
          "id": "_subscriberId"
      },
      "actorSubscriber": 'actorSubscriberId',
      "id": "messageId"
    }
    ....
  ]
}
```

## Delete a message

A single message can be deleted by messageId using these SDK methods. messageId should be a valid objectId parsed as a string.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    const messageId = '64452b58ec0dbb9e41b4dccf';

    await novu.messages.deleteById(messageId);
    ```
  </Tab>
</Tabs>

### Delete a message example response

```javascript theme={null}
{
  data: {
    acknowledged: true,
    status: 'deleted'
  }
};
```

## API Reference Links

* [List Messages API](/api-reference/messages/get-messages/)
* [Delete a Message API](/api-reference/messages/delete-message/)


# Workflows
Source: https://v0.x-docs.novu.co/workflows/notification-workflows

Here you learn all about workflows

A workflow holds the entire flow of steps (nodes) that are sent to the subscriber. This is where all the different channels are tied together under a single entity.

<Note>
  Notification template has been renamed to workflow. Previously, workflow has been referred to as notification template.
</Note>

## Structure

A workflow acts as the blueprint for the notifications that will be sent. The workflow encapsulates the entire flow and rules of messages that are being sent. This is where all the different channels, filters, rules and actions are tied together under a single entity.

<img />

## Workflow Components

<Steps>
  <Step title="Name and Identifier">
    Every workflow will have a name and an identifier that are used to uniquely identify each workflow.
  </Step>

  <Step title="Trigger">
    The "Trigger" refers to an event or action that initiates the workflow. It signifies a call to the Novu API with a specified workflow ID, along with the necessary payload data that the workflow content will utilize.
  </Step>

  <Step title="Channels">
    In Novu, a channel refers to a preconfigured provider through which notifications are dispatched to recipients. In most instances within Novu, these channels utilize the credentials you provide to ensure the delivery of notifications on your behalf. The combination of these credentials and accompanying settings constitutes a configured channel.

    Within the Novu framework, channels are categorized into various types, each of which is linked with at least one corresponding provider that can be tailored as needed:

    * **Email** (examples include Sendgrid, Postmark)
    * **In-App** (such as feeds, toasts, banners)
    * **Push** (such as APNS, FCM)
    * **SMS** (examples include Twilio, Telnyx)
    * **Chat** (such as Slack, Microsoft Teams, and Discord)
    * **Webhook** (used to send webhooks to custom channels or enable your customers to configure webhooks within your product)
  </Step>
</Steps>

## Execution of Workflow Steps

Once a workflow is initiated by its trigger, the steps (and channels) within the workflow are executed in a specific sequence. This sequential execution ensures that each step is completed before the next one begins, maintaining a controlled and orderly flow of the notification process. Here's what you need to know about this process:

* **Sequential Execution:** Each channel in the workflow is activated one after the other, in the order they are listed within the workflow. This method ensures that each step is given the necessary attention and that dependencies or prerequisites of later steps are adequately met.

* **Order of Channels:** The order in which channels are listed in the workflow is crucial, as it dictates the sequence of their execution. You should carefully consider the order when setting up your workflows to align with your notification strategy.

Sequential execution provides a predictable and reliable workflow process, ensuring that messages are sent out in an organized manner and that each step's output potentially influences the subsequent ones.

<br />

<Warning>Once a workflow is triggered, it can not be changed.
<br /> <br /> Workflow can be canceled only using  [DELETE /events/cancel api](/api-reference/workflows/delete-workflow)</Warning>

<Note>Subscriber is not allowed to manage subscriber preference for [critical workflow](/subscribers/preferences#exclude-workflows-from-preferences-critical-workflow)</Note>

## Workflow Groups

Workflow groups are used to categorize workflows based on their purpose or function. This grouping allows you to organize your workflows in a way that makes sense to you and your team. For example, you may want to group all your onboarding workflows or group all your transactional workflows together. You can create as many groups as you need and assign workflows to them as you see fit.

<Info>Currently workflow group is just for reference purposes and cannot be used for bulk action related to all workflows belonging to a workflow group.</Info>

### Working with workflow groups

**To create a workflow group, follow these steps:**

1. Navigate to the **Workflows** page in the Novu interface.
2. Select any workflow from the list.
3. Click on the **cog** icon on the top right side to open the workflow settings.
4. Stay on the *General* settings tab.
5. Click on the **Workflow Group** dropdown and select the group you want to assign to the workflow.
6. To create a new group start writing some text and a **Create New** option will appear. Click on it to create a new group and select this group for this workflow.
7. Click on the update button on the top right side to save the changes for the entire workflow.

<Frame>
  <img />
</Frame>

To edit a workflow group name, follow these steps:

1. Navigate to the **Settings** page in the Novu interface.
2. Copy the **API Key** from settings (Each environment has a different API Key).
3. Navigate to [API Reference](https://docs.novu.co/api-reference/workflow-groups/get-workflow-groups) page to fetch all workflow groups in Novu documentation.
4. Use the previously copied **API Key** as the **Authorization** header. Make sure it is in the correct format `ApiKey <API_KEY>`
5. Click on the send button to fetch all the workflow groups.
6. In the response field copy the **\_id** field of the workfow group that you want to edit.
7. Use the copied **\_id** as the **path parameter** in the request URL of [workflow update](https://docs.novu.co/api-reference/workflow-groups/update-workflow-group) API using the same **API Key** as the **Authorization** header. Write the new name for the group in the **body** field.
8. Click on the send button to update the workflow group name.

<Info>To delete the workflow group use [delete workflow group api](https://docs.novu.co/api-reference/workflow-groups/delete-workflow-group) with the same steps as updating the workflow group name. However, it is not recommended to delete the workflow group if at least one workflow is attached to this workflow group or there exists a change promotion item on the changes page</Info>

## Searching Workflows

Workflows can be searched by their name or trigger identifier. This feature makes it easy to find the desired workflow and quickly access its details.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## FAQs

<AccordionGroup>
  <Accordion title="Workflow Promotion Error: Notification Group Id Not Found">
    To address the error "Notification Group Id not found" when promoting the workflow from dev to prod, it's essential to check the allocation of a notification group to the workflow. Here is an outlined process to validate:

    <Steps>
      <Step title="Go to the workflow settings in Novu's interface." />

      <Step title="Remain within the general settings tab." />

      <Step title="Check the right-hand side for the notification group dropdown." />

      <Step title="Verify if any group is selected. The group's association will be demonstrated here." />
    </Steps>

    <Tip>New notification group can also be created in the drop-down</Tip>

    If a notification group is not associated, this is likely the cause of the issue. Ensure that the relevant Notification Group Id is assigned in the settings. To do so, you would need to choose one from the drop-down list in the workflow settings .

    <Frame>
      <img />
    </Frame>

    Remember, deleting a workflow is not recommended because it can lead to unexpected behavior like this. Instead, updating the workflow group associated with the specific workflow is the right process to address the issue.
  </Accordion>

  <Accordion title="How to disable a workflow for a single subscriber?">
    When all channels are turned off for that subscriber then subscriber will not receive any messages from any channel step, effectively disabling the workflow for that subscriber.

    2. If you want to make a workflow inactive or active, you can do so through the workflow settings. However, it's important to note that this action will affect **all** subscribers.

    3. To disable a workflow for only one subscriber, you can achieve this by having the subscriber disable all channels for that specific workflow through their subscriber preferences. This action will solely impact that particular subscriber.
  </Accordion>

  <Accordion title="What is the difference between workflowId and trigger identifier?">
    `workflowId` is a MongoDB-generated identifier within the Novu system, serving as a unique identifier for workflows. It cannot be modified or altered once generated. This `workflowId` is utilized in several APIs, including the [GET Workflow API](https://docs.novu.co/api-reference/workflows/get-workflow).

    <img />

    A `trigger identifier` is a distinctive label utilized to activate a workflow, typically represented in a slugified format. Novu generates this identifier automatically based on the workflow's name, and it can be modified at a later time if needed. Currently, our system supports only a single trigger identifier per workflow. However, as part of our future plans, we intend to enable the use of multiple trigger identifiers for a single workflow, each capable of initiating the workflow from different sources.

    <img />

    Hence, while `workflowId` refers to the umbrella structure that holds the entire flow of messages, the `trigger identifier` is the specific event that starts this sequence.
  </Accordion>

  <Accordion title="How does Novu prevent duplicate notifications sent to subscribers?">
    The `transactionId` within Novu is a unique identifier that is used to ensure the idempotent nature of notification delivery.

    When you trigger an event to send a notification, you have the option to provide a `transactionId`. If you do not provide one, Novu will generate a UUID for you.

    **This identifier is particularly useful for preventing the same notification from being sent multiple times in case the trigger event is inadvertently called more than once.**

    By leveraging the `transactionId`, you can make idempotent requests, which means if the same `transactionId` is used in another request, Novu's API will recognize it and will not send the same notification again.

    <Note>
      This upholds the principle of idempotency, ensuring that the effect of the operation is the same, no matter how many times the request is repeated with the same `transactionId`.
    </Note>
  </Accordion>
</AccordionGroup>


# Step Conditions
Source: https://v0.x-docs.novu.co/workflows/step-filters

Learn how to customize your notifications flow in Novu.

Workflow step conditions allow you to customize the flow of notifications in your workflow by specifying criteria for which notifications should be delivered.

You can use these conditions to ensure that only relevant notifications are sent to your subscribers, improving the efficiency and effectiveness of your communication.

<Warning>**Step Conditions** used to be called **Step Filters**.</Warning>

## On Condition

* On `payload`: You can specify a list of keywords or values that the `payload` field must match in order for the notification to be delivered. This is useful if you only want to receive notifications that contain certain information.
* On `subscriber`: You can filter which subscriber should receive notifications based on subscriber information. This means that you can send notifications to specific individuals or groups rather than all subscribers. It checks on subscriber attributes. Read more about [subscriber attributes](https://docs.novu.co/subscribers/subscribers#subscriber-attributes).
* On `webhook`: You can use this feature to provide information about subscribers from specified webhook response and use that information to filter the notification flow. For example, if your webhook returns a field indicating whether a subscriber is currently online, you can use this field to send notifications only to online subscribers.
* On `online right now`: You can filter notifications on the basis of the current online status of the subscriber. For example, You can choose to send a notification if the subscriber is currently online or offline.
* On `online in the last "X" time period`: You can use this to filter notifications for a subscriber if the subscriber was online in the last `X` minutes/hours/days.

### Steps to set Conditions

1. Create a step in your workflow. This step will be the location where you will apply your filter.
2. Add a condition to the step. This will allow you to specify the criteria that must be met for the notification to be delivered.

<Frame>
  <img />
</Frame>

3. If you want to add multiple conditions, you will need to choose a logical condition between `AND` and `OR` . This will determine how the conditions are applied to the notification. For example, if you choose `AND`, the notification will only be delivered if all of the conditions are met. If you choose `OR`, the notification will be delivered if any of the conditions are met.
4. Add a rule to the condition. This will specify the criteria that must be met for the notification to be delivered. You can use the `payload`, `subscriber`, or `webhook` field as the basis for your rule. For example, you might specify that the `payload` field must contain a certain keyword or that the `subscriber` must be in a specific group.

## Condition rule

A condition rule is composed of the following fields:

* **On** : This specifies which field the rule should be applied to, such as `Payload`, `Subscriber`, or `Webhook` response.
* **Key** : This specifies the object key that the rule should be applied to. For example, if the `On` field is `Subscriber`, the `Key` field might be `name`, `email` etc.
* **Operator** : This specifies the comparison operator to use when evaluating the rule. Options include **Equal**, **Not equal** , **Larger** , **Smaller** , **Larger or equal**, **Smaller or equal** , **Contains**, **Not contains** and **Is Defined**.
* **Value** : This specifies the `value` to compare to the object key value using the selected `operator`. The value field also accepts variables.

<Frame>
  <img />
</Frame>

**Example of a condition rule**:

In this condition, the notification will only be delivered if the webhook response includes a field called `isOnline` that is set to `true`.

<Frame>
  <img />
</Frame>

## Conditions with Webhook

To filter notifications based on a webhook response, you will need to create a webhook that accepts POST requests and returns a one-level object. The webhook should be set up to receive object the following parameters:

* **subscriber** - This is an object containing information about the subscriber that the notification is being sent to.
* **payload** - This is an object containing the payload of the trigger that initiated the notification.
* **identifier** - workflow identifier is a unique identifier for the notification template being used.
* **providerId** - provider identifier is a unique identifier for the communication provider you used on this notification.
* **channel** - The channel identifier specifies the type of notification channel that was used to send the notification.

### Securing your webhooks

To secure your webhooks, Novu uses the `nv-hmac-256` header as a security measure.

This header contains an HMAC hash that is calculated based on your `API Key` 
and `Environment Id`, ensuring that the request is coming from Novu.
This helps in protection against unauthorized access and tampering with your webhooks.

To verify the authenticity of the request, you can use the following code:

```jsx theme={null}
import { createHmac } from 'crypto';

const hmacHash = createHmac('sha256', 'NOVU_API_KEY').update('ENVIRONMENT_ID').digest('hex');

if (hmacHash === hmac) {
  // The request is authentic
} else {
  // The request is not authentic
}

```

> **ENVIRONMENT\_ID** can be accessed in the webhook subscriber parameter in the request body. **NOVU\_API\_KEY** can be found in the settings section of the Novu client.

The webhook should return a one-level object containing any information that you want to use to filter the notification flow. For example, you might include a field called `isOnline` having value `true` or `false` that specifies whether the subscriber is currently online or not.

## Subscriber online conditions

This allows you to apply a condition on a workflow step based on the `subscriber's` online status. The condition can be applied to determine if the subscriber is currently online or if the subscriber was online in the **X** time-period.

**Example** : To send an email notification to all subscribers who were active within the last 30 minutes, follow these steps:

* On the Workflow editor page, add an `Email` step after trigger in workflow.
* Click on the email step to edit its content template.
* Click on the  `Add conditions` button from the upper right position.

<Frame>
  <img />
</Frame>

* Click `Add condition` to add a rule.
* Select `Last time was online` and choose `minutes` as the time period.
* Enter `30` in the input field.

<Frame>
  <img />
</Frame>

By applying this condition, the notification will only be delivered to subscribers that were last active in the past 30 minutes, ensuring that the message is reaching engaged and active recipients.

### Online condition mechanism

Novu uses a websocket connection within the `notification-center` package to track the online status of subscribers. The `isOnline` and `lastOnlineAt` fields of the subscriber's entity are updated accordingly.

When a subscriber comes online, an active websocket connection is established with the server. Novu then updates the `isOnline` field of the subscriber's entity to `isOnline: true`. When the subscriber disconnects, Novu updates `isOnline: false` and `lastOnlineAt: current_timestamp`.

The online condition feature can be used to determine if a subscriber is online right now or if the subscriber was online within a specific time period.

* To determine if a subscriber is online right now, Novu checks the value of the `isOnline` field. If `isOnline` is `true`, the subscriber is online, otherwise when the `isOnline` is `false` the subscriber is considered offline.
* To determine if a subscriber was online within a specific time period, Novu compares both the `isOnline` and `lastOnlineAt` fields. If `isOnline` is `true`, the subscriber is still online and the condition is applied. If `isOnline` is `false`, the difference between the `current timestamp` and the `timestamp` value of `lastOnlineAt` is calculated. If this difference is within the specified time period, the subscriber was online within that time period and the condition is applied. Otherwise, the condition is not applied.

For example, to determine if a subscriber has been online in the last 5 minutes, Novu checks if the subscriber is currently online or if the `lastOnlineAt` timestamp value is less than or equal to 5 minutes ago. If either of these conditions are met, the condition is applied.

## Subscriber Seen / Read Conditions

This condition gives the flexibility of executing successive step notifications based on the status of previous step notification. It currently works for in-app and email step notifications.

**Typical Use Case**:

You have a set of customers to whom you need to send a 2-step email. However, they should only get the second email if they have read/seen the first email.

With the seen/read condition, you can do the following in a workflow:

* Set the first email step.
* Set a delay.
* Set the second email step.
* Create a condition on the second email step that indicates if the previous step needs to be seen/read before it should be executed.

<Frame>
  <img />
</Frame>

<Note> For this condition to work with emails, the webhook url needs to be set up for the active `email` provider you're using on Novu. It's very essential for the condition to work. No extra set up is needed for `in-app` notifications. </Note>

## Is Defined Condition

Is Defined condition checks whether specified `key` exists or not. It is different from `Equal` and `Not equal` condition. `Equal` and `Not equal` condition checks whether key value is equal to specified value or not, but `Is Defined` condition just checks whether key is present or not.

<Frame>
  <img />
</Frame>

<Note> This condition can be used with subscriber, payload and webhook. It can be applied on all channels. </Note>

## Monitoring the condition's status inside Activity Feed

To check if the notification sent was conditioned or not, visit the `Activity Feed` page.

* Select the notification you're interested in checking the filter status for.
* A new popup `Execution Details` will open up.

<img />

* Click on the notification step row to open up the details for the corresponding step.
* On this screen, you can monitor the notification status along with filter details if any.

<img />

<Info>Digest variables (step.digest, step.events, step.total\_count) are not supported in step conditions.</Info>


# Template Store
Source: https://v0.x-docs.novu.co/workflows/template-store

Display inline code and code blocks

The Novu dashboard features an integrated template store for workflows, offering a range of ready-to-use options.

From basic alerts to intricate sequences, you can select a template, customize it, and swiftly trigger notifications tailored to your needs.
This streamlined process cuts down development time and empowers you to communicate effectively with minimal effort.

<img />


# Variants
Source: https://v0.x-docs.novu.co/workflows/variants

Learn how to create and use multiple variants for workflow steps in Novu.

Variants is a workflow component that empowers users to create multiple versions of a given workflow step.

You can use variants to ensure that only specific versions of your workflow step (e.g Email) are sent to subscribers. These variants are linked to specific conditions. No variant can exist without a condition.

Variants are an integral component of our [multi-tenancy feature](/tenants/introduction#tenant-specific-notification-content).

## Steps to create Variants

In this case, we'll use a workflow Email step. Let's create multiple variants for this step.

1. Create an email step in your workflow.

<Frame>
  <img />
</Frame>

2. Add a variant to the step as shown below.

<Frame>
  <img />
</Frame>

3. A variant must have conditions set. Add a condition or multiple conditions.

<Frame>
  <img />
</Frame>

In this case, we added a condition (as shown below) to check if the tenant identifier passed at the point of trigger is equal to `edenlife`. This is now a **multi-tenant variant**!

Apply conditions to set it successfully.

<Frame>
  <img />
</Frame>

The variant has been created. Click on the **Update** button.

<Frame>
  <img />
</Frame>

4. Head over to the email step again. You will see two variants: the **root variant** & **v1 variant**. The **v1 variant** is the one where you set the tenant condition while the **root variant** is the default version of the email step without a condition.

<Frame>
  <img />
</Frame>

5. You can add different content to the two variants.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

During the notification sending phase, Novu's logic will determine the appropriate variant based on the contextual information that was passed with the trigger event and the conditions applied to the variants.

In this case, if a tenant identifier with the value of `edenlife` was passed with the trigger event, then Novu will select the v1 variant and send to subscribers.

On the other hand, if the tenant identifier has a different value or was not passed with the trigger event, then Novu will select the root variant and send to subscribers.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
      import { Novu } from '@novu/node';

      const novu = new Novu("<NOVU_API_KEY>");

      await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
        {
          to: {
            subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          },
          payload: {
            name: "Hello World",
          },
          tenant: "edenlife"
        }
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
      use Novu\SDK\Novu;

      $novu = new Novu('<NOVU_API_KEY_HERE>');

      $novu->triggerEvent([
        'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
        'payload' => [
          'name' => 'Hello'
        ],
        'to' => [
            'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
        ],
        'tenant': "edenlife"
      ]);
    ```
  </Tab>
</Tabs>

## Variant Conditions

There are so many use cases for variants. It's not limited to [multi-tenancy](/tenants/introduction#tenant-specific-notification-content).

You can set conditions based on the following data:

* Subscriber
* Payload
* Webhook
* Is online
* Last time was online

### Sample Use Cases

1. If you're looking to send a different type of email based on whether a subscriber is online, then variants are the right choice.

2. If you want to send different types of email to subscribers based on the specific type of payload or subscriber data passed with the trigger event, variants are a good choice!


# Data Migrations
Source: https://v0.x-docs.novu.co/additional-resources/data-migrations

Learn how to update your database data through migrations.

On occasion, Novu may introduce features that require changes to the database schema or data.
This usually happens when a feature has a hard dependency on some data being available on a database entity.
You can use migrations to make these changes to your database.

## Running Migrations

To run data migrations, enter the following sequence of commands in your terminal from the [`novuhq/novu`](https://github.com/novuhq/novu) repository root:

```bash theme={null}
npm run setup:project
cd apps/api
npm run migration -- ./migrations/<MIGRATION_PATH>.ts
# e.g. npm run migration -- ./migrations/add-user-contact/add-user-phone.ts
```

Some features may have multiple migrations, in which case you will need to run each migration in the order shown below.

## Migrations History

Below you will find a list of migrations introduced in previous versions of Novu, alongside the migration path to use in the script above.

| Version                                                      | Feature                 | Migration Path(s)                                                                                                                          |
| ------------------------------------------------------------ | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| [v0.23](https://github.com/novuhq/novu/releases/tag/v0.23.0) | API keys encryption     | `./encrypt-api-keys/encrypt-api-keys-migration.ts`                                                                                         |
| [v0.18](https://github.com/novuhq/novu/releases/tag/v0.18.0) | Multi-Provider          | `./integration-scheme-update/add-primary-priority-migration.ts`<br />`./integration-scheme-update/add-integration-identifier-migration.ts` |
|                                                              | Integration Store       | `./novu-integrations/novu-integrations.migration.ts`                                                                                       |
| [v0.16](https://github.com/novuhq/novu/releases/tag/v0.16.0) | In-App Integration      | `./in-app-integration/in-app-integration.migration.ts`                                                                                     |
|                                                              | Secure Flag Fix         | `./secure-to-boolean/secure-to-boolean-migration.ts`                                                                                       |
| [v0.15](https://github.com/novuhq/novu/releases/tag/v0.15.0) | Database TTL            | `./expire-at/expire-at.migration.ts`                                                                                                       |
| [v0.12](https://github.com/novuhq/novu/releases/tag/v0.12.0) | Organization Invite Fix | `./normalize-users-email/normalize-users-email.migration.ts`                                                                               |
| [v0.9](https://github.com/novuhq/novu/releases/tag/v0.9.0)   | Seen/Read Support       | `./seen-read-support/seen-read-support.migration.ts`                                                                                       |
| [v0.8](https://github.com/novuhq/novu/releases/tag/v0.8.0)   | Secure Credentials      | `./fcm-credentials/fcm-credentials-migration.ts`<br />`./encrypt-credentials/encrypt-credentials-migration.ts`                             |
| [v0.4](https://github.com/novuhq/novu/releases/tag/v0.4.0)   | Change Promotion        | `./changes-migration.ts`                                                                                                                   |


# Glossary
Source: https://v0.x-docs.novu.co/additional-resources/glossary

Definitions

## Introduction

In this section, you’ll find a list of key terms, their definitions and various concepts associated with Novu. Familiarising yourself with these will help you understand and use Novu better. They will help you navigate our docs more effectively and utilise Novu to its maximum potential.

If you have any questions or need further clarification on any of the terms listed above, please feel free to reach out to our support team or join our community!

## List of key terms and definitions

## Notification

A brief message or alert that informs users about events, updates, or some other information

## Channels

Novu lets you send notifications across different communication mediums, including emails, in-app messages, push notifications, SMS, and chat. Each of these five communication mediums is referred to as a notification ‘channel’.

<Frame>
  <img />
</Frame>

## Providers

Providers are responsible for handling message delivery across various channels. Novu currently supports multiple notification channels, each with its own set of providers.

* Chat: This channel offers these providers:
  * Discord
  * MS Teams
  * Slack
  * Zulip
* Email: The Email channel features these providers:
  * Sendgrid
  * Amazon SES
  * Sendinblue
  * Resend
  * SparkPost
  * Postmark
  * Mailjet
  * Mailtrap
  * Plunk
  * Braze
  * Mailersend
  * Outlook 365 (based on a custom SMTP server)
  * Mailgun
  * Mandrill
  * Netcore
  * Infobip, and
  * Custom SMTP
* SMS: The SMS channel features these providers:
  * Twilio SMS
  * SMS77
  * Africa’s Talking
  * Infobip
  * Nexmo
  * Plivo
  * Sendchamp
  * AWS SNS
  * Telnyx
  * Termii
  * Firetext
  * Gupshup
  * Clickatell
  * Azure SMS
  * BulkSMS
  * SimpleTexting
  * MessageBird
* Push Notification Providers: This channel includes these providers:
  * Firebase Cloud Messaging (FCM)
  * Expo Push
  * Apple Push Notification Service (APNS)
  * One Signal
  * Pushpad
  * Pusher Beams
  * Push Webhook
* In-app Notification Center: Novu provides you with a set of APIs and components to create rich customized notification center experiences:
  * React component
  * Angular component
  * Vue component
  * Web component
  * iFrame embed
  * Custom styling
  * Headless notification center

## Subscribers

Subscribers are entities designated to receive the notifications you send. Each subscriber in Novu is uniquely identified by their `subscriberId`.

## Actor

An `actor` refers to a user or subscriber who initiates actions that trigger events within the system. Each actor is uniquely identified by an "actorId," also known as "subscriberId," which distinguishes them from others.

Actors hold user-related variables, such as subscriber properties and data payload, containing information like names, emails, and custom data.

Additionally, actors can enhance notifications by allowing their avatars to be displayed, improving the context and identification of notifications.

Including actors in event data enables precise tracking and personalization of actions and events in the Novu platform.

## Workflow

Workflow templates define the flow of messages sent to subscribers.

## Topics

Topics facilitate bulk notifications to multiple subscribers simultaneously, streamlining communication.

## Digest Engine

The digest engine aggregates multiple trigger events into a single message, ensuring efficient communication.

## Delay Actions

Delay actions introduce time intervals between workflow steps, optimizing message delivery timing.

## Step Filter

Step filters customize workflow by specifying notification criteria, enhancing communication efficiency.

## Organizations

Organizations allow separation of notifications across multiple products, managed through the Novu web dashboard.

<Frame>
  <img />
</Frame>

## Environments

Novu runs all your requests in the context of an environment. By default, Novu creates two environments when your account was created, `development` and `production`.

1. `Development environment`: The development environment is used for testing purposes and validating notification changes prior to committing them to the production environment.
2. `Production environment`: It will be your live/production environment, you cannot make changes to this environment directly. You will first have to make the changes in the `development` environment and then promote it to `production`. This is a read-only environment.

## Data associated with an environment

* Subscribers (can’t be promoted to production)
* Workflows (can be promoted to production)
* Messages
* Execution logs
* Connected integrations (can’t be promoted to production)
* Notification feeds (can be promoted to production)
* Brand-related assets and settings

## Team members

Members of a team have access to the Novu web dashboard. This allows you to have individuals work on and manage templates and notifications.

## Layouts

Layouts are HTML designs or structures to wrap the content of email notifications. Layouts can be manipulated and assigned to new or existing workflows within the Novu platform, allowing users to create, manage, and assign these layouts to workflows, so they can be reused to structure the appearance of notifications sent through the platform.


# Idempotent Requests
Source: https://v0.x-docs.novu.co/additional-resources/idempotency

Retry API requests fearlessly, ensuring the operation performs just once!

Our platform has a seamless integration of optional [idempotent](https://en.wikipedia.org/wiki/Idempotence) requests for `POST` and `PATCH` operations.
This integration closely adheres to the [Idempotency-key ietf draft](https://datatracker.ietf.org/doc/draft-ietf-httpapi-idempotency-key-header/).
These idempotent operations deliver the same result regardless of the number of requests made, using an idempotent key.

Leveraging this feature guarantees the safety and reliability of your requests, especially in cases where network or communication issues might inject uncertainty into request outcomes.
Idempotent requests are <b>critical</b> for workflows that require the insurance of only one successful delivery request.

<Note>
  This feature was introduced in version 0.22.0 and is fully operable from 0.24.0 and beyond. Currently, the Idempotency headers are not enabled on the cloud platform but are available for self-hosting.
</Note>

<Warning>
  Please be aware that idempotency might not be supported in all community SDKs.
</Warning>

## How to Perform an Idempotent Request with SDKs

Supporting SDKS will implement Idempotency for you as long as you have retries turned on.
Not only is this seamless but it also ensures that no event request is dropped provided that your system stays up.

<Note>
  Idempotency is only implemented for /events/trigger endpoint.
</Note>

### Idempotent request with api

To make an idempotent request, simply include the `Idempotency-Key: <key>` in your request header.
This key should be a unique client-generated value, boasting enough entropy to prevent collisions;
we recommend a collision-resistant Unique Identifier, such as UUIDv7, CUID, or ULID, as your idempotency keys.

## Understanding Response Replay

Our API stores the status code and response body from your initial idempotent request.
This way if an identical idempotency key appears in a later request,
the API will replay the saved response from the original request - even if it involves client or server error responses.

In the event of a response replay, the response will carry an `Idempotency-Replay: true` header.

## Idempotent Request Responces

Here are some unique pieces constraints you should be aware of especially if you are not using the sdk:

1. A `<key>` exceeding 255 characters will trigger a `400 Bad Request` error.
2. An inconsistent request body compared to the initial request will return a `422 Unprocessable Entity` error.
3. A ongoing processing of the initial request that hasn't yet responded will result in a `409 Conflict` error. This will include a `Retry-After` header.

<Note>
  Results will <b>not</b> saved if an API request is invalid.
</Note>

## Expiring Keys

All idempotency keys are ensured to be automatically removed once they are 24 hours and 1 minute old.
After this period, the reused key will be treated as a new request and response.

## Practical Examples

### Example 1 - No idempotency

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
      to: {
        subscriberId: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      },
      payload: {
        name: "Hello World",
      },
      actor: "actorId",
      tenant: "tenantIdentifier",
    });
    ```
  </Tab>
</Tabs>

### Example 2 - Idempotency Active

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>", {
        retryConfig: {
            retryMax: 5
        }
    });

    // This request is now idempotent
    await novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
      to: {
        subscriberId: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      },
      payload: {
        name: "Hello World",
      },
      actor: "actorId",
      tenant: "tenantIdentifier",
    });
    ```
  </Tab>
</Tabs>

## References

* [https://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/eo](https://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/eo)


# Blog Posts, Articles & Videos
Source: https://v0.x-docs.novu.co/additional-resources/posts-videos-and-articles

Blog posts, articles, and videos

## Blog Posts / Articles

* [🪄✨Building a blog with a liking feature using React, Hanko and Novu 🔥](https://dev.to/novu/building-a-blog-with-a-liking-feature-using-react-hanko-and-novu-1m81)
* [How to add In-App notifications to any web app!](https://dev.to/novu/how-to-add-in-app-notifications-to-any-web-app-1b4n)
* [How To Add In-App Notifications To Your Angular App](https://dev.to/novu/how-to-add-in-app-notifications-to-your-angular-app-2dp3)
* [Creating A Hot New Food Delivery App with Novu](https://dev.to/novu/creating-a-hot-new-food-delivery-app-with-novu-2e75)

## Videos

* [How to add In-App Notifications to your Web app with Novu](https://www.youtube.com/watch?v=KD8zoUb132k)
* [Subscriber (User) Management & Bulk Import Guide](https://www.youtube.com/watch?v=m5nhYEuz86I\&t=92s)
* [Workflow Optimization with Delay Actions](https://www.youtube.com/watch?v=kCMB-WdbzJo)

## External Resources

* [Simplify configuration management with Novu and Configu](https://configu.com/blog/video-first-steps-with-configu/)
* [Vercel and Novu integration](https://vercel.com/integrations/novu)
* [Novu is building open-source notification infrastructure for developers](https://venturebeat.com/business/novu-is-building-open-source-notification-infrastructure-for-developers/)
* [Novu - An open-source notification infrastructure for developers](https://reactjsexample.com/-f0-9f-9a-80-open-source-notification-infrastructure-for-products/)
* [Novu Tackles Notification Infrastructure Management](https://thenewstack.io/novu-tackles-notification-infrastructure-management/)
* [Novu: Omni-channel notification infrastructure for developers](https://www.decibel.vc/articles/novu-omni-channel-notification-infrastructure-for-developers)


# Discord
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/discord

Learn about how to use Discord provider for chat notifications

When using Discord, you will have to store the integration credentials within the subscriber entity. Discord supports two ways to do this:

1. Using the **Discord Webhook** integration.
2. Using the **Discord Bot** integration.

Right now, Novu only supports the **Discord Webhook** integration. This approach has been because the easiest way to set it up is when you have a predefined destination for where the notifications should be sent. It's particularly useful for notifying a specific channel about updates.

**Quickstart:**

To get started with using Novu’s Discord Webhook integration, you need a ‘webhook token’. Here’s how you can generate the same for testing purposes:

1. Go to the channel you want to add the webhook to (you need to be an admin of the discord server).
2. Right-click the channel and select "Edit Channel".
3. Integrations -> Webhooks -> New Webhook
4. Copy the webhook URL.
5. After obtaining the webhook URL in the previous step, you need to store it within the subscriber entity. Doing this ensures that Novu knows where (in which discord channel) to send the notification to. Here’s how to do it:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Discord, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "discord",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "discord-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum to specify the provider.
* The third parameter is the credentials object. In this case, we use the `webhookUrl` property to specify the webhook URL generated in the previous step.

6. You are all set up and ready to send your first chat message via our `@novu/node` package or directly using the REST API in the channel you chose on your discord server.


# MS Teams
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/ms-teams

Learn about how to use MS Teams provider for chat notifications

MS Teams does not need any `API Key` or `Client ID` to send notifications. Our current implementation is based on the [Incoming Webhook URL](https://learn.microsoft.com/en-us/microsoftteams/platform/webhooks-and-connectors/how-to/add-incoming-webhook?tabs=newteams%2Cjavascript). It is a URL that you can use to send messages to a specific channel. This URL needs to be stored on the subscriber entity

Similar to [Discord](https://www.notion.so/Additional-Resources-65ef4aca5d0f4115947030c2f5705101?pvs=21), the credential for this provider needs to be stored in the [subscriber entity](/api-reference/subscribers/update-subscriber-credentials).

## Creating incoming webhook URL

Checkout step by step instructions on microsoft team's documentation on how to [create an incoming webhook url](https://docs.microsoft.com/en-us/microsoftteams/platform/webhooks-and-connectors/how-to/add-incoming-webhook?tabs=newteams%2Cjavascript).

<Frame>
  <img />
</Frame>

## Storing webhook url on subscriber entity

The URL generated above will be the target channel of a subscriber that you want to integrate with. To make this connection, you have to:

1. Copy the URL that you generated above
2. Update the subscriber credentials with this URL using the MS Teams provider id. You can do this step by using the `@novu/node` library, as shown below:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials(
      'subscriberId', 
      ChatProviderIdEnum.MsTeams, // providerId
      { webhookUrl: "<WEBHOOK_URL>" },
      'msteams-MnGLxp8uy' // integration identifier
    );
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "msteams",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "msteams-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum to specify the provider.
* The third parameter is the credentials object, in this case, we use the `webhookUrl` property to specify the MS Teams channel webhook URL or by calling the `Update Subscriber Credentials` endpoint on Novu API. Check endpoint details [here](https://docs.novu.co/api/update-subscriber-credentials/).

<Info>
  If you are looking to use  provider in different way or your usecase is not covered by this documentation, you can always reach out to our team at [support@novu.co](mailto:support@novu.co) or via [Discord](https://discord.novu.co)
</Info>


# Chat Channel Overview
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/overview

Learn the process of configuring and using chat providers with Novu

Novu can be used to deliver chat messages to your customers using a unified delivery API. You can easily integrate your favorite chat provider using the built-in integration store.

<iframe />

## Configuring chat providers

To configure a chat provider, you need to add a new integration to your Novu account. You can do this by navigating to the integration store and clicking on the **Add a provider** button and then select the chat provider you want to configure. You can find the [integration store](https://web.novu.co/integrations?utm_campaign=docs-chat-overview) in the left sidebar of the Novu dashboard.

Each chat provider requires defferent type of credentials. There are few providers which does not require any credentials example: `Discord`

## Sending chat message

Steps to send a chat message using Novu:-

1. Add a chat provider integration to your Novu account from the integration store. Enter credentials if required and save the integration. Follow corresponding provider documentation to get the required credentials.
2. Create a new subscriber

> Step 2 can be skipped if you already have a subscriber. You can use the `subscriberId` of an existing subscriber.

3. [Update](/channels-and-providers/chat/overview#update-credential-webhookurl) the subscriber credential `webhookUrl` for this provider and integration.

4. Create a new [worklow](/workflows/notification-workflows) or use an existing workflow. Add chat channel and [write content](/content-creation-design/notification-content-creation#chat) for the message.

5. Trigger this workflow to above `subscriberId` using trigger identifier

6. Check the chat provider if message is received. If not, check the logs in [activity feed](/activity-feed/introduction) for for any errors.

## Update credential webhookUrl

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Slack, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "slack",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "slack-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

<Info> Integration identifier is similar to Provider identifier but it is different than Provider Id. It is unique for each integration. You can find the `integrationIdentifier` in the integration store page.  </Info>

## Common errors

Common erros and reason of those errors while sending chat messages using Novu.

1. Subscriber does not have a configured channel.
   * if the subscriber does not have credentials set up for any of the chat provider.
2. Webhook URL for the chat channel is missing.
   * `webhookUrl` field is null, undefined or not set. Check using [get subscriber api](/api-reference/subscribers/get-subscriber).
3. Subscriber does not have an active integration.
   * if subscriber have credentials set but integration is either not active or deleted for this credential.

<Tip>
  <MissingProvider />
</Tip>


# Slack
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/slack

Learn about how to use Slack provider for chat notifications

When using Slack you will have to save the integration credentials in the subscriber entity.

This guide will walk you through the steps needed to obtain the `webhookUrl` that Novu requires to send chat messages to your customers.

We will provide the basic flow that the user needs to perform, to successfully send notifications via the Slack integration.

<Note>We've a [dedicated guide](/guides/slack-guide) on integrating Novu in a Slack app.</Note>

### Creating application

This step is optional, if you already have a Slack application you can reuse it.

1. Go to Slack's developer dashboard [https://api.slack.com/apps](https://api.slack.com/apps).
2. Create a new application.

### Integrating Novu with Slack

There are two ways to integrate Novu with Slack - Novu Managed (recommended) and manually managed. Let’s look at both of them in detail:

### 1. Novu Managed (Recommended)

If you use this approach, then Novu will manage the OAuth flow and store the credentials

1. Configure your Slack application as mentioned [below](#configuring-slack-application).
2. You need to make a network request to the `Shareable URL` to perform authentication.
3. You can find the `Shareable URL` in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integrations-slack)

<Frame>
  <img />
</Frame>

4. You can either add the `Add to Slack` button or use the `Shareable URL` directly, in the application you'll be using Novu in.
   <Info>The network request to the 'Shareable URL' will happen when the user clicks the 'Add to Slack' button.</Info>
5. This is to request permission for access (scope: incoming-webhook).
6. You can use the generated `Shareable URL` that is found under the Slack integration in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integrations-slack). The `Shareable URL` should have the following format:

```bash theme={null}
https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials/slack/oauth?environmentId=<ENVIRONMENT_ID>&integrationIdentifier=<PROVIDER_ID>.

```

* `SUBSCRIBER_ID` is a custom identifier used when identifying your users within the Novu platform.
* `ENVIRONMENT_ID` is a context of an environment you can locate your environment id in the setting in the [dashboard settings](https://web.novu.co/settings?utm_campaign=docs-integrations-slack).
* `PROVIDER_ID` (optional) is a unique identifier of the integration and is required when you have multiple slack integrations in Novu. You can locate your integration identifier in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integratons-slack). When not provided, the last created integration will be used.
  If you are using the `Add to Slack` button you have to provide the `Shareable URL` as the `redirect_uri` parameter like in this example. Make sure that the `Shareable URL` is URL encoded:

```html theme={null}
<a
  href="https://slack.com/oauth/v2/authorize?client_id=CLIENT_ID&scope=incoming-webhook&user_scope=&redirect_uri=https%3A%2F%2Fapi.novu.co%2Fv1%2Fsubscribers%2FSUBSCRIBER_ID%2Fcredentials%2Fslack%2Foauth%3FenvironmentId%3DENVIRONMENT_ID%26integrationIdentifier%3DINTEGRATION_IDENTIFIER"
  ><img
    alt="Add to Slack"
    height="40"
    width="139"
    src="https://platform.slack-edge.com/img/add_to_slack.png"
    srcset="
      https://platform.slack-edge.com/img/add_to_slack.png    1x,
      https://platform.slack-edge.com/img/add_to_slack@2x.png 2x
    "
/></a>
```

7. Either you use the 'add to Slack' button or use the `Shareable URL`, you should land here:

<Frame>
  <img />
</Frame>

8. Then you'll be redirected to the address you chose in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integrations-slack):

<Frame>
  <img />
</Frame>

<Info>You can use the URL of whichever page you want your users to land on, after successful execution</Info>
9\. That's it! Now you can trigger your workflow and send notifications:

<Frame>
  <img />
</Frame>

<Note>Don't forget to check out our [dedicated guide](/guides/slack-guide) on integrating Novu in a Slack app for more.</Note>

### 2. Manually managed

To use the manually managed option, you need to generate a `webhookUrl` and plug it into your backend.

1. Goto 'Incoming Webhooks' in your Slack app settings and turn it on.

<Frame>
  <img />
</Frame>

2. Click on the 'Add New Webhook to Workspace':

<Frame>
  <img />
</Frame>

3. Now, go ahead and select the channel in which you want to send notifications and click 'allow'.

<Frame>
  <img />
</Frame>

4. Then, copy the 'webhookUrl' from Slack.

<Frame>
  <img />
</Frame>

5. Now, you need to save the `webhookUrl` on the relevant subscriber entity in Novu. Here's an example to do the same using our Node SDK:

## Update credential webhookUrl

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Slack, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "slack",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "slack-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum.Slack if you’re using Node, else string of Slack to specify the provider.
* The third parameter is the credentials object. In this case, we use the `webhookUrl` property to specify the webhook URL generated in the previous step.

6. You are all set up and ready to send your first chat message via our @novu/node package or directly using the REST API.

## Configuring Slack application

1. Go to OAuth & Permissions on Slack's Developer Dashboard and add your REDIRECT\_URL in Redirect URLs.
   * If you use a manual Management solution, add the API endpoint you created in Step 1.
   * If you use the Novu Managed solution add `https://api.novu.co/v1/subscribers`.
2. Go to Incoming Webhooks from the left menu and Activate Incoming Webhooks.
3. Go to Manage Distribution and at the bottom of the page, tick Remove Hard Coded Information and Activate Public Distribution.

### Enabling HMAC Encryption

To enable Hash-Based Message Authentication Codes, you need to do the following steps:

1. Visit the integration store page and enable HMAC encryption under your chat provider.

2. The next step would be to generate an HMAC encrypted subscriberId on your backend:

   ```jsx theme={null}
   import { createHmac } from 'crypto';

   const hmacHash = createHmac('sha256', process.env.NOVU_API_KEY)
     .update(subscriberId)
     .digest('hex');

   ```

3. Add the newly created hash HMAC to the Sharable URL as a query.

This concludes the Slack provider guide.


# How to send WhatsApp Business notifications with Novu
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/whats-app

Learn about how to use WhatsApp for chat notifications

## Getting Started

To integrate WhatsApp Business with Novu, You will have to create a facebook developer app and obtain the necessary credentials.

### Step 1: Create a Facebook Developer App

Visit the [Facebook Developer Portal](https://developers.facebook.com/apps/) and create a new app.

Select "Other" for "What do you want your app to do?" and select "Business" for "Select an app type".

### Step 2: Setup WhatsApp Product

On the App Setup page, click on "Set Up" under the "WhatsApp" product. You will need to create or add a Facebook Business Account to your app.

### Step 3: Send a Sandbox Message

Copy the following pieces and paste them in the Novu WhatsApp Business integration settings:

* Temporary Access Token - Access API token Field
* Phone Number ID - Phone Number Identification Field

<Warning>
  It's important to note that the test credentials for whatsapp cannot be used in production and will expire in 24 hours.
  You will need to submit your app for review to obtain production credentials.
</Warning>

### Step 4: Add a Test Phone Number

You can add a test phone number to the sandbox by clicking on the "Add Phone Number" button.
This number can be used to test your integration with Novu before submitting for a review.

### Step 5: Send a test notification from Novu

You can now create a new Workflow with a "Chat" node, and add your content. Save your workflow, and click on "Trigger Notification" Button.

In the to field, specify the phone number you added in the sandbox, and click on "Send Notification".

```json theme={null}
{
  "subscriberId": "TEST_SUBSCRIBER_ID",
  "phone": "+11111111111"
}
```

and in the `overrides` field, add the following:

```json theme={null}
{
  "chat": {
    "template": {
      "name": "hello_world",
      "language": {
        "code": "en_US"
      }
    }
  }
}
```

<Info>
  For test credentials you can only used the built in Whats App Template.
</Info>

## Going to Production

### Register a Business Phone Number

To go live you will need to add a real business phone number and submit your app for review.
Follow the [Facebook Instructions](https://developers.facebook.com/docs/whatsapp/cloud-api/get-started/add-a-phone-number) on how to proceed.

### Generate a permanent access token

Follow the [Facebook Instructions](https://developers.facebook.com/docs/whatsapp/business-management-api/get-started/) on how to generate a permanent access token.
Depending on your use case.

### Create a WhatsApp Template

You will need to create a WhatsApp Template to send notifications to your customers. Create a template in the [Business Manager](https://business.facebook.com/wa/manage/message-templates) and submit it for review.
After your template is approved, you can use the `template_name` to send notifications to your customers.

To send a notification with a template, you will need to add the following to the `overrides` field:

```typescript theme={null}
novu.trigger('workflow-id', {
    to: {
        subscriberId: "SUBSCRIBER_ID",
        phone: "+11111111111"
    },
    payload: {},
    overrides: {
        chat: {
            template: {
                name: "template_name",
                language: {
                    code: "en_US"
                }
            }
        }
    }
})
```


# Zulip
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/zulip

Learn about how to use Zulip provider for chat notifications

Zulip does not need any API Key or client ID to push messages in it. All it needs is the webhook URL of the channel you want to send messages to. That itself acts as the credential.

Similar to Discord, the credential for this provider needs to be stored in the subscriber entity.

## Getting a Zulip webhook URL

* Sign up or Login to your Zulip account.

* Click on the Settings icon in the top right corner of the screen, and then click "Personal settings" from the drop-down menu.

<Frame>
  <img />
</Frame>

* Click "Add a new bot" button in "Bots" tab.

<Frame>
  <img />
</Frame>

* Set bot type as "Incoming webhook".

<Frame>
  <img />
</Frame>

* Click the small link icon to generate webhook URL for provider. Set Integration as `Slack compatible webhook`, choose your channel and copy webhook URL.

<Frame>
  <img />
</Frame>

## Connecting our subscribers to Zulip

The URL generated above will be the target channel of a subscriber that you want to integrate with. To make this connection, you have to:

1. Copy the URL that you generated above

2. Update the subscriber credentials with this URL using the Zulip provider id. You can do this step by using the `@novu/node` library, as shown below:

## Update credential webhookUrl

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Zulip, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "zulip",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "zulip-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum to specify the provider.
* The third parameter is the credentials object, in this case, we use the `webhookUrl` property to specify the MS Teams channel webhook URL or by calling the `Update Subscriber Credentials` endpoint on Novu API. Check endpoint details [here](https://docs.novu.co/api/update-subscriber-credentials/).

3. You are all set up and ready to send your first chat message via our `@novu/node` package or directly using the REST API.


# Apple Push Notification Service (APNS)
Source: https://v0.x-docs.novu.co/channels-and-providers/push/apns

Learn how to use the Apple Push Notification Service (APNS) provider to send push notifications using Novu

[Apple Push Notification Service](https://docs.expo.dev/push-notifications/overview/), as the name suggests, is a notification delivery service provided by Apple.

Apple provides two authentication methods to make a secure connection to APNs. The first is Certificate-Based Authentication (using a .p12 certificate). The second is Token-Based Authentication (using a .p8 key). We'll make use of the **.p8** key.

To enable APNS integration, you need to create an [Apple Developer](https://developer.apple.com/) account with an [Admin role](https://appstoreconnect.apple.com/access/users).

To generate the p8 key for your account:

1. Head over to **Certificates, Identifiers & Profiles > Keys**.
2. Register a new key and give it a name.
3. Enable the Apple Push Notifications service (APNs) checkbox by selecting it.
4. Click the **Continue** button and on the next page, select **Register**.
5. Download the **.p8** key file.

You also need the following to connect to APNs:

1. **Key ID** - This is a 10-character unique identifier for the authentication key. You can find it in the key details section of the newly created key in your Apple developer account.
2. **Team ID** - This is available in your Apple developer account.
3. **Bundle ID** - This is the ID of your app. You can find it in the app info section of your Apple developer account.

The overrides field supports all [Notification payload](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/generating_a_remote_notification?language=objc) values, as shown below:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    abc: 'def', // If the notification is a data notification, the payload will be sent as the data
  },
  overrides: {
    apns: {
      payload: {
        aps: {
          notification: {
            title: 'Test',
            body: 'Test push',
          },
          data: {
            key: 'value',
          },
        },
      },
    },
  },
});
```

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    key1: 'val1',
    key2: 'val2', // If the notification is a data notification, the payload will be sent as the data
  },
  overrides: {
    type: 'data',
    apns: {
      headers: {
        'apns-priority': '5',
      },
      payload: {
        aps: {
          alert: {
            'loc-key': 'GAME_PLAY_REQUEST_FORMAT',
            'loc-args': ['Shelly', 'Rick'],
          },
          sound: 'demo.wav',
        },
      },
    },
  },
});
```

Before triggering the notification to a subscriber(user) with push as a step in the workflow, make sure you have added the subscriber's device token as follows:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.APNS, {
      deviceTokens: ['token1', 'token2'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "apns",
      "deviceTokens": ["token1", "token2"],
      "integrationIdentifier": "apns-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.


# Expo Push
Source: https://v0.x-docs.novu.co/channels-and-providers/push/expo-push

Learn how to use the Expo push provider to send push notifications using Novu

[Expo Push](https://docs.expo.dev/push-notifications/overview/) is a notification delivery service provided by Expo.

To enable Expo Push integration, you need to create an [Expo Application Services (EAS)](https://expo.dev/)account and generate an access token in the EAS dashboard.

The overrides field supports all [Message Request](https://docs.expo.dev/push-notifications/sending-notifications/#message-request-format) values. An example of the same follows:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    abc: 'def',
  },
});
```

Before triggering the notification to a subscriber(user) with push as a step in the workflow, make sure you have added the subscriber's device token as follows:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,PushProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.EXPO, {
      deviceTokens: ['token1', 'token2'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "expo",
      "deviceTokens": ["token1", "token2"],
      "integrationIdentifier": "expo-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.


# Firebase Cloud Messaging (FCM)
Source: https://v0.x-docs.novu.co/channels-and-providers/push/fcm

Learn how to use the Firebase Cloud Messaging (FCM) provider to send push notifications using Novu

[Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging) is a free notification delivery service provided by Google Firebase.

To enable the FCM integration, you need to get your service account key from the [Firebase Console](https://console.firebase.google.com/).

## Generating a Service Account Key JSON

To acquire the account key JSON file for your service account

1. Select your project, and click the gear icon on the top of the sidebar.
2. Head to project settings.
3. Navigate to the service account tab.
4. Click **Generate New Private Key,** then confirm by clicking **Generate Key.**
5. Clicking **Generate Key** downloads the JSON file.

After that, paste the entire JSON file content in the Service Account field of the FCM provider in the integration store on Novu’s web dashboard.

Make sure your service account json content contains these fields

```json theme={null}
{
  "type": "service_account",
  "project_id": "PROJECT_ID",
  "private_key_id": "PRIVATE_KEY_ID",
  "private_key": "PRIVATE_KEY",
  "client_email": "FIREBASE_ADMIN_SDK_EMAIL",
  "client_id": "CLIENT_ID",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "CLIENT_X509_CERT_URL"
}
```

## FCM Overrides

The overrides field supports apns, android, webpush and fcmOptions overrides

| Override Field | Type / Interface | Link                                                                                                                                                                                         |
| -------------- | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| android        | AndroidConfig    | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.androidconfig](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.androidconfig) |
| apns           | ApnsConfig       | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.apnsconfig](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.apnsconfig)       |
| webPush        | WebpushConfig    | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.webpushconfig](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.webpushconfig) |
| fcmOptions     | FcmOptions       | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.fcmoptions](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.fcmoptions)       |

## Setting Device Token

Before triggering the notification to a subscriber(user) with push as a step in the workflow, make sure you have added the subscriber's device token as follows:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      PushProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials(
      'subscriberId', 
      PushProviderIdEnum.FCM, 
      { deviceTokens: ['token1', 'token2'] }, 
      'fcm-MnGLxp8uy'
    );
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "fcm",
      "credentials": {
        "deviceTokens" : [
          "token1", 
          "token2"
        ]
      },
      "integrationIdentifier": "fcm-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

## SDK Trigger Example

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
  to: {
    subscriberId: "<SUBSCRIBER_ID>",
  },
  payload: {
    abc: "def", // If the notification is a data notification, the payload will be sent as the data
  },
  overrides: {
    fcm: {
      // type: 'data' => will turn this into an FCM data notification, where the payload is sent as a data notification. If the type is not set, you can use the "data" override to send notification messages with optional data payload
      type: "data",

      // URL of an image to be displayed in the notification.
      imageUrl: "https://domain.com/image.png",

      // If type is not set, you can use the "data" override to send notification messages with optional data payload
      data: {
        key: "value",
      },

      // Check FCM Overrides section above for these types
      android: {},
      apns: {},
      webPush: {},
      fcmOptions: {},
    },
  },
});
```

Device/notification identifiers can be set by using [setCredentials](#set-device-token) or by using the `deviceIdentifiers` field in overrides.

<Info> Novu uses FCM version V1</Info>

## Relative Link in Webpush

Suppose you’re using the Firebase (FCM) provider to send push notifications to web browsers via Novu and want users to be returned to the website after clicking the notification.

In that case, you must use the `link` property with a relative URL.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from "@novu/node";

    const novu = new Novu("<NOVU_API_KEY>");

    novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
      to: {
        subscriberId: "<SUBSCRIBER_ID>",
      },
      payload: {
        abc: "def", // If the notification is a data notification, the payload will be sent as the data
      },
      overrides: {
        fcm: {
          webPush: {
            fcmOptions: {
              link: "/foo",
            },
          },
        },
      },
    });
    ```
  </Tab>

  <Tab title="Curl">
    ```bash theme={null}
    curl --location --request POST 'https://url.to.our.selfhosted.novu' \
        --header 'Authorization: ApiKey KEY' \
        --header 'Content-Type: application/json' \
        --data-raw '{
            "name": "workflow-name",
            "to": {
                ...
            },
            "overrides": {
              "fcm": {
                "webPush": {
                  "fcm_options": {
                    "link": "/foo"
                  }
                }
              }
            }
          }'
    ```
  </Tab>
</Tabs>

## FCM Cost

As per Firebase [pricing](https://firebase.google.com/pricing), **Cloud Messaging** product is free of cost to use. If other Firebase products are used, the cost will be charged as per the product.

## FAQs

<AccordionGroup>
  <Accordion title="The registration token is not a valid FCM registration token">
    You may come across an error like so:

    ""Sending message failed due to "The registration token is not a valid FCM registration token""".

    This error happens because of invalid or stale token. The fix for this is to remove old tokens, generate a new token and save it into user subscribers.
  </Accordion>

  <Accordion title="FCM notifications sent successfully with no error but push notification is not received in device">
    Try to generate a new token after clearing device cache and retry with this fresh token.
  </Accordion>

  <Accordion title="Sending message failed due to 'Requested entity was not found'">
    This error occurs when your token is no longer valid. To fix this, generate a new token and use it.
  </Accordion>

  <Accordion title="Subscriber does not have a configured channel error">
    This error occurs if the fcm integration is active but subscriber is missing from the fcm credentials (deviceTokens). The credentials (deviceTokens) for the subscriber needs to be set.
  </Accordion>
</AccordionGroup>


# Onesignal
Source: https://v0.x-docs.novu.co/channels-and-providers/push/onesignal

Learn how to use the Onesignal provider to send push notifications using Novu

[OneSignal](https://onesignal.com/) is a paid push notification service that supports sending messages via both [Apple Push Notification Service](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server) (APNs) as well as [Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging) (FCM).

To configure the OneSignal integration, you will need an active account which has credentials for APNs, FCM or both, and have access to the `OneSignal App ID` and `Rest API Key` available via your [application's settings page](https://documentation.onesignal.com/docs/keys-and-ids).

# Setting the Device Token

Once OneSignal has been configured with your credentials for APNs/FCM, and the OneSignal SDK has been [set up and configured](https://documentation.onesignal.com/docs/onboarding-with-onesignal#step-1-setup-onesignal-sdk) for your application, your users will begin to be automatically assigned a unique OneSignal [player\_id](https://documentation.onesignal.com/docs/users#player-id) identifier by the SDK.

This identifier allows targeting your user when sending push notifications without having to retrieve the specific Android or iOS device tokens - which are managed by OneSignal.

In order to target the OneSignal user from Novu, you must register the OneSignal `player_id`as the `deviceToken` for your Novu subscriber. This value can be retrieved via the [OneSignal SDK](https://documentation.onesignal.com/docs/users-and-devices#finding-users) for your platform.

Once you have the user's `player_id` value, the `deviceToken` for your Novu subscriber can be set via:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.OneSignal, {
      // Your user's unique 'player_id' from OneSignal
      deviceTokens: ['ad0452ca-3ca7-43b5-bf9b-fa93fd322035'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "one-signal",
      "deviceTokens": ["ad0452ca-3ca7-43b5-bf9b-fa93fd322035"],
      "integrationIdentifier": "one-signal-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

# SDK Trigger Example

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    abc: 'def', // If the notification is a data notification, the payload will be sent as the data
  },
});
```

Device/notification identifiers can be set by using [setCredentials](https://docs.novu.co/channels/email/resend/#set-device-token) or by using the `deviceIdentifiers` field in overrides.


# Push Channel Introduction
Source: https://v0.x-docs.novu.co/channels-and-providers/push/overview

Learn how to send push notifications with Novu using external providers like FCM, Expo etc.

Push notifications are short, targeted messages delivered to a user's device or browser, often through mobile apps or websites. They serve as a powerful communication tool, offering real-time updates, reminders, and personalized content. Push notifications can range from news alerts and social media updates to promotional offers and important app notifications.

These messages are designed to engage users and keep them informed about relevant events or activities, even when they are not actively using an app or browsing a website. They play a crucial role in user engagement and retention for businesses and organizations, as they can re-engage users and prompt them to take specific actions.

Novu can be used to deliver push notifications to your customers devices using a unified delivery API. Both Mobile and Web push notifications are supported.

## Using push channel with Novu

To send a push notification to subscribers (users) using Novu:

* Add a push channel provider in integration store
* Add push channel as a step in existing or new workflow.
* Add static or dynamic content using variables in push step fields
* Store provider specific device tokens/identifiers in subscriber profile. Read provider specific documentation on how to obtain and store device tokens.
* Make sure all provider specific steps are configured properly before triggering workflow. Read provider related documentation for all required steps.
* Trigger the workflow.

## Supported providers

* [Firebase Cloud Messaging (FCM)](/channels-and-providers/push/fcm)
* [Expo Push](/channels-and-providers/push/expo-push)
* [Apple Push Notification Service](/channels-and-providers/push/apns)
* [OneSignal](/channels-and-providers/push/onesignal)
* [Pushpad](/channels-and-providers/push/pushpad)
* [Push Webhook](/channels-and-providers/push/push-webhook)

<Note>Novu supports multiple active providers for push channel.</Note>

<Tip>
  <MissingProvider />
</Tip>

## Managing push device tokens

To send push notifications to subscribers, you need to store device tokens or identifiers in subscriber profiles. These tokens are unique identifiers that help push notification providers deliver messages to the correct devices. Each provider has its own method for obtaining and storing device tokens.

Novu offers to ways of keeping your device tokens in sync with subscriber profiles:

* Just-in-time: Pass device tokens in the payload when triggering a workflow. Novu will automatically update subscriber profiles with the new device tokens.
* Manual: Update subscriber profiles with device tokens using the Novu Set Credentials API.

### Just-in-time

When triggering a workflow, you can pass the `channels` array on the subscriber object with the device tokens for the push provider of your choice. Here is an example with fcm:

```typescript theme={null}
novu.trigger('workflow-id', {
  to: {
    subscriberId: 'subscriber-id',
    channels: [
      {
        providerId: 'fcm',
        credentials: {
          deviceTokens: ['token-1', 'token-2'],
        },
      },
    ],
  },
  payload: {},
});
```

### Manual

Use the Novu Set Credentials API to update subscriber profiles with device tokens. You can read more about the API in the [API Reference](/api-reference/subscribers/update-subscriber-credentials) or the [FCM Example](/channels-and-providers/push/fcm#setting-device-token)

## Frequently Asked Questions

### How to remove one device token from subscriber credentials?

To remove a device token from subscriber credentials, you need to get the current device tokens from subscriber credentials, remove all deviceTokens, remove the token you want to remove and then update the subscriber credentials with new device tokens.

<Tabs>
  <Tab title="Node.js">
    ```ts theme={null}
    import { Novu, PushProviderIdEnum } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    // fetch subscriber details
    const subscriber = await novu.subscribers.get('subscriberId');

    // get current device tokens from subscriber credentials for the provider
    const currentDeviceTokens = subsciber.data.data.channels.find(
        // _integrationId can also be checked in place of providerId ;
        (channel) => channel.providerId === PushProviderIdEnum.FCM,
    ).credentials.deviceTokens;

    // remove all device tokens
    await this.novu.subscribers.setCredentials(
        'subscriberId',
        PushProviderIdEnum.FCM,
        { deviceTokens: [] },
    );

    // remove the token you want to remove
    const newDeviceTokens = currentDeviceTokens.filter(
        (token) => token !== 'token-to-be-removed',
    );

    // update subscriber credentials with new device tokens
    await this.novu.subscribers.setCredentials(
        'subscriberId',
        PushProviderIdEnum.FCM,
        { deviceTokens: newDeviceTokens },
    );
    ```
  </Tab>
</Tabs>


# Push Webhook
Source: https://v0.x-docs.novu.co/channels-and-providers/push/push-webhook

Learn how to use the Push Webhook provider to send  notifications using Novu

Push Webhook provider is a bit different different from other push providers as it does not depend on other third party services.
Users can use their own api url as webhook url and novu will make a post request on that webhook url.

## Steps To Configure

1. Go to [integration store](https://web.novu.co/integrations?utm_campaign=docs-push-webhook) and click on `Add a provider` button. Choose `Push` channel and then `Push Webhook` provider.
2. Enter your Webhook URL. For quick testing use [this](https://webhook.site/) website.
3. Enter Secret Hmac Key. Novu will use this secret hmac key to encrypt the data using `HMAC SHA256` algorithm and send the hash as value of `x-novu-signature` header. User can use `x-novu-signature` header to test authenticity of the request. Read more [here](#checking-authenticity)
4. Click on the update button.
5. Update the subscriber credentials using SDK or API. Read more [here](#set-device-token)

<Info>Your webhook url should accept `POST` request.</Info>

## Set Device Token

This step is a mandatory step. Other push providers have third party dependencies where a device token can be generated. But in case of push webhook provider, there is no any way to generate device token. Any random string can be used as device token.

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    // PushProviderIdEnum.PushWebhook = push-webhook
    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.PushWebhook, {
      deviceTokens: ['ANY_RANDOM_STRING'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "push-webhook",
      "deviceTokens": ['ANY_RANDOM_STRING'],
      "integrationIdentifier": "push-webhook-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

## Example paylod sent by novu to webhook url

```json theme={null}
{
  "target": [
    "subscriber-token-for-push-webhook-provider"
  ],
  "title": "Push Webhook message title",
  "content": "push Webhook content body",
  "overrides": {
    "data": {
      "custom_message": "this is custom message from payload push webhook demo",
    }
  },
  "payload": {
    "custom_message": "this is custom message from payload push webhook demo",
    "__source": "test-workflow",
    "subscriber": {
      // subscriber fields
      "_id": "65c0d71c0959a38e8857b131",
      "_organizationId": "organizationId",
      "_environmentId": "environmentId",
      "firstName": "Pawan",
      "lastName": "Jain",
      "phone": "+123456789",
      "subscriberId": "push-webhook-demo-subscriber-id",
      "email": "pawan+push+web+hook+demo@domain.com",
      "channels": [
        {
          "credentials": {
            "deviceTokens": [
              "subscriber-token-for-push-webhook-provider"
            ]
          },
          "_integrationId": "integrationId",
          "providerId": "push-webhook"
        }
      ],
      "data": {
        // custom data field of subscriber
        "isDeveloper": "true"
      },
      "deleted": false,
      "createdAt": "2024-02-05T12:39:56.379Z",
      "updatedAt": "2024-02-05T12:54:08.684Z",
      "__v": 0,
      "id": "65c0d71c0959a38e8857b131"
    },
    "step": {
      // digest variables
      "digest": false,
      "events": [],
      "total_count": 0
    }
  }
}
```

## Checking Authenticity

```typescript theme={null}
import crypto from "crypto"

// secret key added in step 3
const secretKey = "YOUR_HMAC_SECRET_KEY"

// function to handle webhook url route request
async acceptNovuPushWebHookRequest(request, response){

  const payloadSentByNovu = request.body
  const hmacHashSentByNovu = request.headers['x-novu-signature']

  const actualHashValue = crypto
    .createHmac('sha256', secretKey)
    .update(payloadSentByNovu, 'utf-8')
    .digest('hex');

  if(hmacHashSentByNovu === actualHashValue){
    // handle the notification
    console.log("Request sent by Novu")
  } else {
    throw new Error("Not a valod request")
  }
}
```


# Pusher Beams
Source: https://v0.x-docs.novu.co/channels-and-providers/push/pusher-beams

Learn how to use the Pusher Beams provider to send push notifications using Novu

[Pusher Beams](https://pusher.com/beams/) is a cross-platform push notification API service provided by Pusher.

To enable Pusher Beams integration, you need to create a Pusher Beams Instance and use both `Instance ID` and `Secret Key` from the Instance [dashboard](https://dashboard.pusher.com/beams/).

# Setting the Device Token

Once Pusher Beams instance has been created, and the Pusher Beams SDK has been [set up and configured](https://pusher.com/docs/beams/reference/all-libraries/) for your application, you can associate users with their devices using [Authenticated Users](https://pusher.com/docs/beams/guides/publish-to-specific-user/web/).

This identifier allows targeting your user when sending push notifications without having to retrieve the specific Web, Android or iOS device tokens - which are managed by Pusher Beams.

In order to target the Pusher Beams user from Novu, you must register the Pusher Beams Authenticated Users with their `userId` as the `deviceToken` for your Novu subscriber. This value can be retrieved via [getUserId()](https://pusher.com/docs/beams/reference/web/#getuserid) method from the SDK for your platform.

Once you have the user's `userId` value, the `deviceToken` for your Novu subscriber can be set via:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.PusherBeams, {
      // Your user's unique 'userId' from Pusher Beams
      deviceTokens: ['userId-from-pusher-beams'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "pusher-beams",
      "deviceTokens": ['userId-from-pusher-beams'],
      "integrationIdentifier": "pusher-beams-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

# SDK Trigger Example

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    custom_data: 'custom_data', // the payload will be sent as notification data object. Cannot contain the key “pusher”
  },
});
```


# Pushpad
Source: https://v0.x-docs.novu.co/channels-and-providers/push/pushpad

Learn how to use the Pushpad provider to send web push notifications using Novu

[Pushpad](https://pushpad.xyz) is a web push service that supports sending notifications to all major browsers (Chrome, Firefox, Edge, Safari, etc.) via FCM, Mozilla autopush, Windows Push Notification Services and Apple Push Notification service, with just one simple API.

To configure the Pushpad integration, you will need an active account and you need to have a `Pushpad Auth Token` (from the [account settings](https://pushpad.xyz/access_tokens)) and the `Pushpad Project ID` (from the project settings).

# Setting the Device Token

Once Pushpad has been configured with your credentials and the Pushpad SDK has been [set up and installed](https://pushpad.xyz/docs/pushpad_pro_getting_started) on your website, you can [assign a user ID (uid)](https://pushpad.xyz/docs/identifying_users) to the push subscriptions.

This identifier (`uid` or `user ID`) allows targeting a specific browser when sending push notifications.

In order to target the Pushpad user from Novu, you must register the Pushpad `uid` as the `deviceToken` for your Novu subscriber. For example, if you invoked the [Pushpad JavaScript SDK](https://pushpad.xyz/docs/javascript_sdk_reference) with `pushpad('uid', 'user123')`, then `user123` is the user ID for that browser.

Once you have the `uid` value, the `deviceToken` for your Novu subscriber can be set using this code:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.Pushpad, {
      // the user ID (uid) that you used for Pushpad
      deviceTokens: ['user123'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "pushpad",
      "deviceTokens": ['user123'],
      "integrationIdentifier": "pushpad-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

# SDK Trigger Example

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {}
});
```

The devices of the subscriber that should receive the notifications can be set by using `setCredentials` or by using the `deviceIdentifiers` field in overrides.


# Add a new provider
Source: https://v0.x-docs.novu.co/community/add-a-new-provider

Steps to add a new provider to Novu

Interested in expanding Novu's capabilities? By contributing to our growing ecosystem, you can enhance Novu's reach and impact.

## How to add a new provider?

Novu currently supports five channels `in_app`, `push`, `email`, `chat` and `sms`.

For `in_app` we support only our own provider, so new providers cannot be added to this channel. For the other four channels, we support the integration of external providers. This guide will help in adding new providers for any of these 4 channels.

In this guide, we are adding a new provider for the email channel, but all of the mentioned steps are similar for other channels as well.

## Description

Providers allow us to handle message delivery over multiple channels.

We have multiple providers for each channel (SMS, Email, Push and Chat). To get started with adding a new provider let's look at setting up our repository.

## Requirements

* Node.js version v20.8.1
* MongoDB
* Redis
* **(Optional)** pnpm - Needed if you want to install new packages
* **(Optional)** localstack (required only in S3 related modules)

Need help installing the requirements? [Read more here](/community/run-in-local-machine)

<Note> We have used pnpm package manager in this guide. You can use npm as well. </Note>

## Initialization

Fork the novu repository and clone it in your local machine.

```shell theme={null}
git clone https://github.com/<'YOUR_GITHUB_USER_NAME'>/novu.git
```

To set up the repository, run the initial setup command:

```shell theme={null}
pnpm run setup:project
```

At the root of the project build the `node` package to get started.

```shell theme={null}
cd packages/node && pnpm run build
```

## Generate provider

After the project is initialized, a new provider can be generated using the below command.

```shell theme={null}
pnpm run generate:provider
```

<Note> Use the above command at the root of the project. </Note>

Choose the provider type.

```shell theme={null}

? What type
❯ EMAIL
  SMS
  PUSH
  CHAT
```

Use `up` and `down` arrow to switch `channel` type and press `enter` to select.

For this example, we will be selecting `EMAIL` as our provider type. The name for our provider will be `example-provider`.

```
? Write the provider name`kebab-cased` (e.g. proton-mail, outlook365, yahoo-mail): example-provider
```

Make sure your selected name is not conflicting with our existing provider's name. Boilerplate files for this new `example-provider` is generated in your local machine project.

> In above example, we have given our provider name as example-provider for simplicity. If provider you want to add have name as twilio, don't use twilio-provider as name, instead use twilio only. If one provider supports multiple channels like infobip supports both sms and email channels, use infobip-email or infobip-sms to differentiate these providers.

Once our `example-provider` is generated we will need to begin working from within `packages/providers/src/lib/example-provider` directory. Make sure to write the test for this new provider.

```ts packages/providers/src/lib/example-provider/example-provider.provider.ts theme={null}
import {
  ChannelTypeEnum,
  ISendMessageSuccessResponse,
  IEmailOptions,
  IEmailProvider,
} from '@novu/stateless';

export class ExampleProviderEmailProvider implements IEmailProvider {
  id = 'example-provider'
  channelType = ChannelTypeEnum.EMAIL as ChannelTypeEnum.EMAIL;

  constructor(
    private config: {
      apiKey: string;
    }
  ) {}

  async sendMessage(options: IEmailOptions): Promise<ISendMessageSuccessResponse> {
    return {
      id: 'id_returned_by_provider',
      date: 'current_time'
  }
}
```

### Template test case for `example-provider`.

```ts packages/providers/src/lib/example-provider/example-provider.provider.sepc.ts theme={null}
import { ExampleProviderEmailProvider } from './example-provider.provider';

test('should trigger example-provider library correctly', async () => {});
```

<Info> Add the provider's SDK as a dependency in the provider's package.json file. Run `pnpm run setup:project` to build all dependencies again. Use this new sdk method to complete the provider's `sendMessage` function. Check the **[reference links for adding new providers](#reference-for-adding-new-providers)** section for each channel's provider example. </Info>

### Add provider logos

In order to present this new provider in the `integration store` we need logos in dark and light mode. Add dark color svg logo in  `apps/web/public/static/images/providers/dark/sqaure` directory and light color svg logo in  `apps/web/public/static/images/providers/light/sqaure` directory.

Use the provider name as the file name. The sample name for our above-added provider is `example-provider.svg`.

## Add config items to the list

In order to build the UI integration store, we need to provide it list of all provider integrations. This part is made up of two parts:

* Create credentials config
* Add ProviderId Enum
* Add provider configuration to the providers list

### 1. Create credentials config

Every provider requires some credentials to create an instance. Novu will add these credentials fields in the integration store provider's form so that users can use their credentials to connect to their preferred provider to use for that channel notification. For example, in the above added `example-provider`, we have only one credential `ApiKey`. We will need to add a config object for `example-provider` with all existing provider's configs like below.

```tsx libs/shared/src/consts/providers/credentials/provider-credentials.ts theme={null}
export const exampleProviderConfig: IConfigCredentials[] = [
  {
    key: CredentialsKeyEnum.ApiKey,
    displayName: "API Key",
    description: "This is API key for example provider",
    type: "text",
    required: true,
  },
  ...mailConfigBase,
];
```

1. Here the `key` is of type `CredentialsKeyEnum`.

> If a new key is added, add this key at these 3 places:-
>
> * In `CredentialsKeyEnum` at file `libs/shared/src/consts/providers/provider.enum.ts`
> * In `CredentialsDto` at file `apps/api/src/app/integrations/dtos/credentials.dto.ts`
> * In `credentials` field of `integrationSchema` at file `libs/dal/src/repositories/integration/integration.schema.ts`

2. `displayName` is a human-friendly easy to understand name which will be shown in the provider integration form for this credential.
3. `description` is a field that can be used to share more information about the credential.
4. `type` here means text field type. this can be a string for text, text for text-area, or a switch for the toggle.
5. `required` is of boolean type.
6. `mailConfigBase` is an object having default credentials required by any `email` provider. Make sure not to add duplicate providers which are already there in `mailConfigBase`. In the case of another channel provider, we will use that channel config base in place of `mailConfigBase`.

> A credential can be made secret by adding in ./secure-credentials.ts file.

### 2. Add ProviderId Enum

Add this new provider id in the respective channel provider id enum in file `libs/shared/src/consts/providers/provider.enum.ts`. As our `example-provider` is of email type, add this in `EmailProviderIdEnum` with all existing providers like below

```tsx libs/shared/src/consts/providers/provider.enum.ts theme={null}
export enum EmailProviderIdEnum {
  ExampleProvider = "example-provider",
}
```

### 3. Add provider to providers list

Now we need to add the provider data to the list located at `libs/shared/src/consts/providers/channels/email.ts`. Note that the `id` is the provider's name, `displayName` is the provider's name in Pascal's case, `credentials` are the ones we created in the previous step, `logoFileName` should be as it was on the adding logo step (with the format type included).

```tsx libs/shared/src/consts/providers/channels/email.ts theme={null}
{
  id: 'example-provider',
  displayName: 'Example Provider',
  channel: ChannelTypeEnum.EMAIL,
  credentials: exampleProviderConfig,
  // Use valid documentation link
  docReference: 'https://docs.example-provider.com/',
  logoFileName: { light: 'example-provider.svg', dark: 'example-provider.svg' }
}
```

## Add provider handler in the API

### 1. Adding the provider dependency in the application-generic package

In the previous step, we created a standalone provider package that will be published to NPM. However currently in our development environment, it is not yet published. In order to use it locally please go to the `package.json` located in `packages/application-generic/package.json` and add it manually to the dependencies list: `"@novu/<NEW_PROVIDER_NAME>": "^<VERSION>"`

> Please note that the provider name and version can be found from the provider package.json you created earlier.

After adding the dependency run `pnpm run setup:project` from the root of the mono repo. so, it can create the required symlinks for the newly created package.

### 2. Create a provider handler

In order to map internally the different providers’ credentials, we need to add a provider handler at the respective channel handlers located. For Email, it can be found at `apps/packages/application-generic/src/factories/mail/handlers`. Other channel handlers can also be found here.

Create a new file `example-provider.handler.ts` here with the following code

```tsx packages/application-generic/src/factories/mail/handlers/example-provider.handler.ts theme={null}
import { ChannelTypeEnum } from "@novu/shared";
import { ExampleProviderEmailProvider } from "@novu/example-provider";
import { BaseHandler } from "./base.handler";

export class ExampleProviderHandler extends BaseHandler {
  constructor() {
    super("example-provider", ChannelTypeEnum.EMAIL);
  }

  buildProvider(credentials, from: string) {
    const config: { apiKey: string } = { apiKey: credentials.apiKey };

    this.provider = new ExampleProviderEmailProvider(config);
  }
}
```

Add this line given below to export this handler

```tsx packages/application-generic/src/factories/mail/handlers/index.ts theme={null}
export * from "./example-provider.handler";
```

### 3. Add handler to factory

The last step is to initialize the handler in the factory located in `packages/application-generic/src/factories/mail/mail.factory.ts`

```tsx packages/application-generic/src/factories/mail/mail.factory.ts theme={null}
import { ExampleProviderHandler } from "./handlers";

export class MailFactory {
  handlers: IMailHandler[] = [new ExampleProviderHandler()];
}
```

### Final Steps

Now, build the project again using this command

```shell theme={null}
pnpm run setup:project
```

Run novu in your local machine. Read [here](/community/run-in-local-machine) to learn on how to run novu on a local machine and test this new provider.

Run the below command in the root of the project to run the providers test

```shell theme={null}
pnpm run test:providers
```

If everything is working fine without any error, commit your local branch changes, push this branch and create a new pull request to our main repo.

Hurray 🎉! You have successfully added a new provider in Novu!

<Info>️ In this guide, we have used only one credential `apiKey` for our `example-provider`. This is for reference purposes only. A provider can have more than one credential as per its `SDK` requirements. At each step, you will need to add all credentials carefully. Check providers referenced below for more information. </Info>

### Reference for Adding New Providers

* [SendGrid Email Provider](https://github.com/novuhq/novu/blob/next/providers/sendgrid/src/lib/sendgrid.provider.ts)
* [Twilio SMS Provider](https://github.com/novuhq/novu/blob/next/providers/twilio/src/lib/twilio.provider.ts)
* [FCM Push Provider](https://github.com/novuhq/novu/blob/next/providers/fcm/src/lib/fcm.provider.ts)
* [Slack Chat Provider](https://github.com/novuhq/novu/blob/next/providers/slack/src/lib/slack.provider.ts)
* [Resend - How to add an Email Provider to Novu](https://dev.to/novu/resend-how-to-add-an-email-api-provider-to-novu-49cd)


# Changelog
Source: https://v0.x-docs.novu.co/community/changelog

See the most recent changes and learn about how to shape Novu's future

<Card title="Novu's Changelog" icon="map" href="https://github.com/novuhq/novu/releases/">
  Learn about what's changed, new features, bug fixes, and see Novu's history across versions.
</Card>

Using the changelog, you can:

* Keep an eye on the latest updates,
* Learn more about the newly added features and improvements, and
* Stay informed about bug fixes and enhancement

## Getting involved:

Community is at the heart of everything we do at Novu. To get more involved with the community, you can:

* **Fork and Contribute** to our open issues as well as suggest new ideas at our [github repository](https://github.com/novuhq/novu)
* **Join our community** to ask questions, engage with other users and share ideas. Here's the [joining link.](https://discord.gg/novu?ref=docs-join-our-community)
* **Participate in our office hours** to learn more and connect with our core team. Join us [here.](https://www.youtube.com/@novuhq/streams)

<Tip>
  Remember, we're not building just another product, but a community of passionate developers who shape its evolution. Our changelog isn't just a list of updates but a reflection of our journey together. Your voice matters, and your ideas and feedback are what fuel our progress and shape our future. So, join us in this adventure, and – Let's build something amazing, one feature at a time!
</Tip>


# Novu Community Code of conduct
Source: https://v0.x-docs.novu.co/community/code-of-conduct

The set of rules and guidelines that govern interaction among community members

As a community-driven company, Novu is committed to creating an inclusive and welcoming environment for all members, regardless of factors such as age, body size, disability, ethnicity, gender identity, experience level, education, socio-economic status, nationality, personal appearance, race, religion, or sexual orientation.

However, diverse communities may face challenges, such as potential misunderstandings and miscommunications. To ensure respectful interactions, free from behaviour that may create an unsafe environment, we have established this Code of Conduct.

These guidelines do not cover every possible scenario comprehensively but serve as a guiding light towards courteous interactions among community members, aligning with the overarching principle of avoiding unprofessional behaviour. This Code of Conduct applies to all events and participants, aiming to maintain a welcoming and healthy environment for our community.

Traits of a Novu community member include:

### Being considerate and using appropriate channels

Contributions of every kind have far-ranging consequences. Just as your work depends on the work of others, decisions you make surrounding your contributions to the Novu community will affect your fellow community members. Use appropriate channels for what you’re about to say and refrain from tagging a role that sends out a lot of pings. You are strongly encouraged to take those consequences into account while making decisions.

### Adhering to these standards

It's crucial to keep in mind that our community members are from all kinds of backgrounds, so the members are expected to:

* Demonstrate empathy and kindness toward other people
* Be respectful of differing opinions, viewpoints, and experiences
* Give and accept constructive feedback gracefully
* Accept responsibility and apologise to those affected by mistakes, and learn from such experiences
* Focus on what is best not just for us as individuals, but for the overall community!

### Patience

Our community thrives on the generosity of volunteered time. Questions, contributions, and support requests may embark on a time-travelling journey before finding their destination. Repeated "bumps" or persistent "reminders" don’t display patience and are looked down upon. Lastly, it is a bad practice to ask general questions to a specific person (in direct messages for example). Try to ask in public as much as you can, and patiently wait for the response

### Inclusivity, kindness and respectfulness

Please be courteous and respectful to fellow members. Avoid offensive comments related to age, body size, disability, ethnicity, gender identity, experience level, education, socio-economic status, nationality, personal appearance, race, religion, or sexual orientation.

Strictly prohibited are sexualized imagery, violence, intimidation, stalking, disruptions, sharing personal information without explicit permission, unwanted physical contact, and unwelcome sexual attention.

Use inclusive language respecting our community's diversity.

Avoid assumptions about others' backgrounds. Maintain a positive and professional demeanour, refraining from threatening or inappropriate behaviour.

**We have zero tolerance for discrimination**. Any form of discrimination, including harassment, will lead to immediate consequences, potentially expulsion.

### Inquisitive

***The only stupid question is the one that does not get asked***.

We encourage our users to ask early and ask often. Rather than asking whether you can ask a question (the answer is always yes!), instead, simply ask your question. You are encouraged to provide as many specifics as possible.

Code snippets in the form of images are bad practice. Instead, use text formatted as code (using backticks) on Discord or simply send a gist. Refrain from pasting multiple lines of code directly into the chat channels - instead use [gist.github.com](http://gist.github.com/) or another paste site to provide code snippets.

### Helpful

Novu welcomes users of all skill levels. We were all beginners once, and a supportive environment is essential for the community to thrive. While it can be repetitive to answer the same questions, members are expected to be courteous and helpful to everyone.

Avoid sarcastic responses and prioritize useful information. Everyone should read the provided documentation. We're here to answer questions, offer guidance, and suggest workflows, but not to do your job for you.

### Anti-harassment policy

Harassment includes (but is not limited to) all of the following behaviors:

* Offensive comments related to gender (including gender expression and identity), age, sexual orientation, disability, physical appearance, body size, race, and religion.
* Derogatory terminology including words commonly known to be slurs
* Posting sexualized images or imagery in public spaces
* Deliberate intimidation
* Stalking
* Posting others’ personal information without explicit permission
* Sustained disruption of talks or other events
* Inappropriate physical contact
* Unwelcome sexual attention

Immediate compliance is expected from participants asked to cease harassing behaviour. Sponsors must adhere to the anti-harassment policy, refraining from using sexualized images or creating a sexualized environment at events. Volunteer organizers, including meetup staff, should also avoid sexualized attire.

Continuing inappropriate behaviour after being asked to stop constitutes harassment, even if not explicitly mentioned in this policy. It is respectful to stop doing something when asked to do so, and all community members are expected to promptly comply with such requests.

### Reporting policy violations

Instances of abusive, harassing, or otherwise unacceptable behaviour may be reported to anyone with administrative power in the community (Admins or Moderators on Discord, members of the ‘DevRel’ role), or to the local organizers of an event or to [support@novu.co](mailto:support@novu.co). Meetup organizers are encouraged to prominently display points of contact for reporting unacceptable behaviour at local events.

If a participant engages in harassing behaviour, the meetup organizers may take any action they deem appropriate. These actions may include but are not limited to warning the offender, expelling the offender from the event, and barring the offender from future community events.

Organizers will be happy to help participants contact security or local law enforcement, provide escorts to an alternate location, or otherwise assist those experiencing harassment to feel safe during the meetup. We value the safety and well-being of our community members and want everyone to feel welcome at our events, both online and offline.

We expect all participants, organizers, speakers, and attendees to follow these policies at all of our event venues and event-related social events.

### Enforcement Guidelines

Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:

1. **Correction**

* `Community Impact`: Use of inappropriate language or other behaviour deemed unprofessional or unwelcome in the community.
* `Consequence`: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behaviour was inappropriate. A public apology may be requested.

2. **Warning**

* `Community Impact`: A violation through a single incident or series of actions.
* `Consequence`: A warning with consequences for continued behaviour. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.

3. **Temporary Ban**

* `Community Impact`: A serious violation of community standards, including sustained inappropriate behaviour.
* `Consequence`: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.

4. **Permanent Ban**

* `Community Impact`: Demonstrating a pattern of violation of community standards, including sustained inappropriate behaviour, harassment of an individual, or aggression toward or disparagement of classes of individuals.
* `Consequence`: A permanent ban from any sort of public interaction within the community.

The Novu Community Code of Conduct is licensed under the Creative Commons Attribution-Share Alike 3.0 license.

Our Code of Conduct was adapted from Codes of Conduct of other open-source projects, including:

* **Contributor Covenant**
* **Elastic**
* **The Fedora Project**
* **OpenStack**
* **Ansible**
* **Puppet Labs**
* **Ubuntu**

Community Impact Guidelines were inspired by Mozilla's code of conduct enforcement ladder.

For answers to common questions about this code of conduct, see the FAQ at [https://www.contributor-covenant.org/faq](https://www.contributor-covenant.org/faq).

Translations are available at [https://www.contributor-covenant.org/translations](https://www.contributor-covenant.org/translations).


# Feature Flags
Source: https://v0.x-docs.novu.co/community/feature-flags

Learn how to enable/disable specific features in Novu

Feature flags allow to turn certain functionality on and off based on configuration. In this way, users can preview beta features in their deployments.

To enable the specific feature, you need to pass an environment variable to all services:

<Note>
  Feature flag environment variable accepts boolean values: `true` or `false`.
</Note>

* `IS_MULTI_PROVIDER_CONFIGURATION_ENABLED` adds ability to connect multiple providers per channel and make them active. It also shows redesigned integrations store page.

<Frame>
  <img />
</Frame>

* `IS_MULTI_TENANCY_ENABLED` adds ability to manage tenants from dashboard.

<Frame>
  <img />
</Frame>

* `IS_TEMPLATE_STORE_ENABLED` enables template store which contains pre-made workflows for common use cases (like **Password Reset** workflow etc).

<Frame>
  <img />
</Frame>


# Get involved with the Novu Community
Source: https://v0.x-docs.novu.co/community/get-involved

Your guide for engaging with the Novu Community

## Our Community

At Novu, we're a vibrant, open-source community driven by passion, collaboration, and a shared love for pushing boundaries. We believe in the power of community-driven development, where every voice matters and every contribution counts. As such, contributions are at the heart of how we evolve and progress forward.

## Join the conversation

* Read our [code of conduct](/community/code-of-conduct)
* Say “Hi!” in our [Discord Server](https://discord.gg/novu?ref=docs-community-introduction)
* Explore our [open issues](https://github.com/novuhq/novu/issues)
* Subscribe to our newsletter [to stay in the know](https://novu.co/novu-community-2-0/?utm_campaign=docs-comm2-get-involved)

## Getting help

Our fellow community members are always ready to help you get past a blocker. However, you can take a few things into consideration to help them help you:

* Share as many details as you can share. It will help us in debugging the issue.
* If there is any bug, please share steps to reproduce that bug.
* If there is any issue in running Novu on a local machine, please share system details like operating system, RAM size, npm version and node version.
* If there is any issue in our backend SDKs, please mention the SDK version and relevant details.
* If looking for self-hosting support, please share `Novu Version` and remote server details. Our latest version is `0.24.0`. Please be patient with self-hosting help. We are a small team and we will try our best to help you.

<Tip>Intercome is suitable if you're using Novu cloud or. Kindly use Discord or Github for community self-hosting questions.</Tip>

## Contributing

All community members are of one of the following four types:

1. Open source users
2. Active member
3. Power member
4. Novu Ambassador

### Become an active community member

* Everyone who joins our community becomes an open-source user automatically.
* You can become an active community member by:
  * Submitting >2 PRs
  * Opening >2 issues
  * Sending >5 messages on Github
  * Commenting >3 times on Github
* Active community members are one step closer to becoming Power community members and then an active moderator.

### Become a power community member

* All active community members are eligible to become a power community member and can become so by having at least one of the following:
  * Submitting 3 PRs
  * Opening 3 Issues
  * Sending 10 Discord messages
  * Commenting >10 times on Github
* Power community members are just one step away from becoming a Novu ambassador.

### Become a Novu Ambassador

A Novu ambassador is a trusted power member of the community that can do the following:

* Love exploring and sharing their knowledge of any technology with other developers.
* Often write and speak about Novu.
* Possess strong Novu expertise and often help and support Novu users within the community.
* Socially influence developers with some knowledge of Novu.
* Consistently contribute to Novu OSS product.

We are launching the Novu Ambassador program soon with amazing perks. Stay tuned!

## Activities

Are you passionate about notifications like we are? There are many different—and easy—ways to get involved.

### Help in onboarding and answering questions.

* Welcome new users into the community
* Answer questions in the [community support channel](https://discord.com/channels/895029566685462578/1019663407915483176).
* Offer input and opinions about various solutions you have tried.

### Improve our documentation

* Check out our[GitHub repo](https://github.com/novuhq/docs)
* No documentation is perfect, and neither is ours
* Help us improve our docs by
  * Updating outdated examples
  * Correcting typos and language for clarity
  * Find and fix broken links, etc.

### Help with the SDKs

* Link to contributors guide([https://github.com/novuhq/novu/blob/next/CONTRIBUTING.md](https://github.com/novuhq/novu/blob/next/CONTRIBUTING.md))
* We have SDKs in various languages and frameworks, most written and maintained by community members.
* You can either become a maintainer there or help the existing maintainers by bringing the SDK up to speed with the latest features present in the core product.
  * We have backend SDKs in the following: [Node.js](https://github.com/novuhq/novu/tree/next/packages/node), [PHP](https://github.com/novuhq/novu-php), [.NET](https://github.com/novuhq/novu-dotnet), [Elixir](https://github.com/novuhq/novu-elixir), [Go](https://github.com/novuhq/go-novu), [Ruby](https://github.com/novuhq/novu-ruby), [Python](https://github.com/novuhq/novu-python) [Laravel](https://github.com/novuhq/novu-laravel), and [Kotlin](https://github.com/novuhq/novu-kotlin)
  * And client-side SDKs in the follwing: [Vue](https://github.com/novuhq/novu/tree/next/packages/notification-center-vue), [React](https://github.com/novuhq/novu/tree/next/packages/notification-center), [Angular](https://github.com/novuhq/novu/tree/next/packages/notification-center-angular), [Web Component](https://github.com/novuhq/novu/tree/next/packages/notification-center), [iframe embed](https://docs.novu.co/notification-center/client/iframe), and [Headless Javascript.](https://docs.novu.co/notification-center/client/headless/get-started)

### Create content

* Content writers program: Apply to become a content writer with us and get paid to write about use-cases highlighting how you solved a problem using Novu
* Write an article about what you built with Novu and share it with the community. We’ll give you a shout out!

### PRs, issues, and bug reports

* Check out our [contributors guide](https://github.com/novuhq/novu/blob/next/CONTRIBUTING.md)
* Once you’ve gone through our [development process](https://docs.novu.co/community/run-in-local-machine), you can contribute directly to open issues.
* Open a new issue if a relevant one isn’t already open.
* Also, you can create bug reports if you find a bug somewhere.
* Or a feature request if you find something that should be a feature but isn't.

<Info>
  At Novu, we believe that no contribution is small, and the only wrong question is the one that doesn’t get asked. So feel free to ask any question or raise that Pull Request. You’re always welcome here! 🤗
</Info>

### Participate in office hours

* We have frequent (replace with interval— twice weekly, weekly, etc.) and topic-specific office hours that offer the ability to engage in real-time with Novu staff and other community members
* In these sessions, offer input, opinions, examples, etc. to contribute!

We’re excited to have you on board and look forward to your valuable contributions!

Together, we’ll shape the future of Novu. 🫂


# MacOS/Linux
Source: https://v0.x-docs.novu.co/community/machine-setup

Learn how to configure your local machine to run Novu

## Terminal upgrade (Optional)

### Install ZSH

ZSH is a shell on steroids, it has multiple plugins and functionality that can save a lot of time.

To install zsh run in your command line:

```shell theme={null}
sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
```

<Note>
  If you previously haven’t installed git on the machine, a prompt to install
  git will show up. After installation, run the `sh` command from above again.
</Note>

<Note>
  Make sure you have a `~/.zshrc` exists, if not it might be an indicator that
  the installation failed for some reason.
</Note>

### ZSH auto-complete plugin

Add the autocomplete plugin for autocompleting previously typed commands in the shell. Follow the instructions [here](https://github.com/zsh-users/zsh-autosuggestions/blob/master/INSTALL.md#oh-my-zsh).

### Powerlevel10k (optional)

[Powerlevel10k](https://github.com/romkatv/powerlevel10k) is a theme for Zsh. It emphasizes [speed](https://github.com/romkatv/powerlevel10k#uncompromising-performance), [flexibility](https://github.com/romkatv/powerlevel10k#extremely-customizable), and [out-of-the-box experience](https://github.com/romkatv/powerlevel10k#configuration-wizard).

1. Clone the repository:

   `git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k`

2. Set `ZSH_THEME="powerlevel10k/powerlevel10k"` in `~/.zshrc`.

3. Restart your terminal and follow the onboarding wizard to configure it to your likings and preferences.

## Command Line Tools, Homebrew & Casks

Every developer utilizes *Command Line Tools*. A simple terminal command will allow you to download these. It will ask you to confirm after you have entered the command.

```shell theme={null}
xcode-select --install
```

### Homebrew & Casks

[Homebrew](https://brew.sh/), it’s the missing package manager for macOS, and quite powerful at that.

Copy and paste the following code into your terminal to install Homebrew.

```shell theme={null}
/bin/shell -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

It will ask you to enter 'Return' to confirm the installation.

<Note>
  After installation run, the `echo` and `eval` commands shown on screen to add
  brew to your shell executables
</Note>

## Setting up git

To set up git and create an access token for GitHub, suggested installing [GitHub Desktop](https://www.notion.so/Dev-Machine-Setup-98d274c80fa249b0b0be75b9a7a72acb?pvs=21) before.

## Helpful settings

Show hidden files in Finder: `cmd + shift + .` or in the terminal:

```shell theme={null}
defaults write com.apple.finder AppleShowAllFiles YES
```

## Development Environment

### Node & NVM

For installing node we suggest installing it using [NVM](https://github.com/nvm-sh/nvm) (Node Version Manager) for easily managing multiple node versions.

1. Install nvm on your machine.

```shell theme={null}
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | shell
```

<Note>
  Make sure that you have installed zsh previously, so NVM can automatically
  inject the executable to PATH in the .zshrc config file.
</Note>

2. After installing nvm and checking that it’s in the path by running `nvm --version` in your CLI. You can now install our node version:

<Note>
  After running the install script, if you get `nvm: command not found` or see
  no feedback from your terminal after you type `command -v nvm`, simply **close
  your current terminal, open a new terminal**, and try verifying again.
</Note>

3. Optional for M1 processors - Install Rosetta.

Rosetta enables a Mac with Apple silicon to use apps built for a Mac with an Intel processor.

```shell theme={null}
softwareupdate --install-rosetta
```

### PNPM

For package management, we use [PNPM](https://pnpm.io/) instead of npm or yarn to speed up our install times and space efficiency. To install pnpm globally run:

```shell theme={null}
npm install -g pnpm@8.9.0
```

### Docker

Follow the installation guide on [docker website](https://docs.docker.com/desktop/mac/install/) to install docker on your own machine. For ease of use, we suggest installing **Docker Desktop**.

### AWS CLI

Follow the instructions to install the AWS CLI so you can use it to create env later on, based on existing S3 buckets:

[Installing or updating the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

You should get something like this:

<Frame>
  <img alt="AWS CLI" />
</Frame>

If needed, see:

[Resolve "Unable to locate credentials" error in Amazon S3](https://aws.amazon.com/premiumsupport/knowledge-center/s3-locate-credentials-error/)

### Run LocalStack

This is needed only when you upload files (for example - an image) in the admin panel from your local environment.

LocalStack emulates cloud service that runs in a single container on your computer. So you can run your AWS applications on your local machine without connecting to the remote cloud provider.

1. Build a container and run it:

```shell theme={null}
docker run --rm -it -p 4566:4566 -p 4571:4571 localstack/localstack
```

2. Create local S3 buckets needed for the app:

   In **local** environment:

   ```shell theme={null}
   aws --endpoint-url=http://localhost:4566 s3 mb s3://novu-local
   ```

   In **test** environment:

   ```shell theme={null}
   aws --endpoint-url=http://localhost:4566 s3 mb s3://novu-test
   ```

3. Update cors:

   ```json theme={null}
   aws --endpoint-url=http://localhost:4566 s3api put-bucket-cors --bucket novu-local --cors-configuration file://cors.json
   ```

   ```json cors.json theme={null}
   {
     "CORSRules": [
       {
         "AllowedOrigins": ["*"],
         "AllowedHeaders": ["*"],
         "AllowedMethods": ["GET", "PUT", "POST", "DELETE"],
         "MaxAgeSeconds": 3000,
         "ExposeHeaders": ["x-amz-server-side-encryption"]
       }
     ]
   }
   ```

### MongoDB

After installing brew you can easily install the MongoDB community edition.

1. Tap the [MongoDB Homebrew Tap](https://github.com/mongodb/homebrew-brew) to download the official Homebrew formula for MongoDB and the Database Tools, by running the following command in your macOS Terminal:

```shell theme={null}
brew tap mongodb/brew
```

2. To install MongoDB, run the following command in your macOS Terminal application

   1. You might need to update the Command Line Tools to be compatible with Xcode - see

   [Sign in with your Apple ID](https://developer.apple.com/download/all/?q=Xcode)

```shell theme={null}
brew install mongodb-community@5.0
```

3. Run the service in the background and start automatically after restart.

```shell theme={null}
brew services start mongodb/brew/mongodb-community@5.0
```

### Redis

After installing homebrew run the redis installation

```shell theme={null}
brew install redis
```

After installation run the service to start on system start as well.

```shell theme={null}
brew services restart redis
```

### Local dev domain (Optional)

This will allow you to use [local.novu.co](http://local.novu.co) instead of [localhost](http://localhost) when accessing the service on your machine.

Open the `/etc/hosts` file:

```shell theme={null}
sudo nano /etc/hosts
```

And add the [local.novu.co](http://local.novu.co) domain

```shell theme={null}
127.0.0.1       local.novu.co
```

### Code Editor

Feel free to install your favorite code editor. We supply licenses for [WebStorm](https://www.notion.so/WebStorm-7570ab1037bf494d88d0f9b544ae3b79?pvs=21), or you can [Visual Studio Code](https://code.visualstudio.com/download) if you prefer it.

### Productivity tools

* GitHub Desktop (Optional)

GitHub Desktop simplifies the development workflow and interaction with Git. [Download](https://desktop.github.com/) the client from their website.

* Clean your Dock bar (Optional)

For better productivity and wellness, we suggest removing the not-used apps from LaunchBar. Don’t worry if you will remove most apps from there. You can always use the spotlight to open the apps you need. Clean workspace === Happy life :)
Right Click on the app icon > Options > Remove from Dock

<Frame>
  <img alt="Dock" />
</Frame>


# Monorepo Structure
Source: https://v0.x-docs.novu.co/community/monorepo-structure

Learn the components of Novu's monorepo

In this guide, we will explore the Novu mono-repo structure and high-level structure of the different libraries and services we use.

## Setting up the monorepo

Novu uses [PNPM](https://pnpm.js.org/) as its package manager, and [NX](https://nx.dev/) as its build CLI tool. PNPM reduces the installation time and generates symlinks for all the internal packages we use.

To initialize the monorepo, run the following command from the root of the project:

```bash theme={null}
npm run setup:project
```

This will:

* run `pnpm install`, which will download all the needed dependencies and create symlinks for packages.
* copy the `.env.example` file to the `.env` file for the API service.
* execute the `npm run build` command to build all the dependency trees locally.

For additional information on running Novu locally, visit the [run locally](https://docs.novu.co/community/run-in-local-machine) guide.

## Apps

The `apps` folder contains high-level applications and APIs. The app's outputs usually contain deployable units that a user can interact with either as an API or as a web/cli application.

<Steps>
  <Step title="API">
    The API package is our main service for handling backend logic. It handles anything from authentication, authorization, workflow management, triggering events, etc... This is where the Novu business logic is handled.
  </Step>

  <Step title="WS aka Web Socket">
    This is the WebSocket NestJs server which connects to the widget and provides real-time updates about new notifications to the widget consumer.
  </Step>

  <Step title="Web aka Admin Panel">
    This is the Novu admin panel which is used to visually communicate with the API. You can configure workflows, manage content, enable or disable notifications, visually track the notification activity feed, etc...

    The `WEB` project is a create-react-app built, well, with React. 😄
  </Step>

  <Step title="Widget">
    This is the client of our embeddable notification center widget. It is consumed mainly with the embed script in an Iframe. We can access it on port 4500 to interact with it directly.
  </Step>

  <Step title="Worker">
    This is our service for managing and handling workers.
  </Step>
</Steps>

## Libs

<Steps>
  <Step title="@novu/dal">
    The `DAL` is our Data-Access-Layer. This is our connection to the DB service and wraps MongoDB and mongoose. When another service or API needs to consume the DB, it does not do that directly but uses the DAL as an interface. Importing `mongoose` directly outside the `dal` is not allowed.
  </Step>

  <Step title="@novu/testing">
    This is a utility library that contains testing helpers. The testing helpers can generate test sessions and other functionality for e2e and unit-tests between our services.
  </Step>

  <Step title="@novu/shared">
    The shared library contains reusable code and typescript interfaces between client and server packages. Code in the shared library should not contain any sensitive content because it can be accessed and downloaded by the web or other clients.
  </Step>

  <Step title="@novu/embed">
    This is the connector between our client's web app and the widget project. It’s a small shim script that generates an iframe and attaches it to a client-specified div to host the notification widget.

    If you are familiar with the Google Analytics embedded snippet or intercom-like embeddings, it uses the same mechanics.
  </Step>
</Steps>

## Packages (on npm)

<Steps>
  <Step title="@novu/node">
    A Standalone Node.js wrapper around the Novu API. Exists to provide type-safe and easier access to the different API endpoints Novu exposes (Triggers, subscribers, etc…).
  </Step>

  <Step title="@novu/nest">
    A Nest.js wrapper around the `@novu/node` package was created by the community to easily interact with the core library from a nest project. Also released on NPM as a package.
  </Step>

  <Step title="@novu/notification-center">
    React component library that contains widget bell with the notification center. Can get override of components like ‘bell icon’, and ‘notification center’.
  </Step>
</Steps>

## Providers

These are the API wrappers created by the community to wrap communication providers in the following channels:

Novu provides a single API to manage providers across multiple channels with a simple-to-use interface.

### 💌 Email

* [Sendgrid](https://github.com/novuhq/novu/tree/main/providers/sendgrid)
* [Netcore](https://github.com/novuhq/novu/tree/main/providers/netcore)
* [Mailgun](https://github.com/novuhq/novu/tree/main/providers/mailgun)
* [SES](https://github.com/novuhq/novu/tree/main/providers/ses)
* [Postmark](https://github.com/novuhq/novu/tree/main/providers/postmark)
* [Custom SMTP](https://github.com/novuhq/novu/tree/main/providers/nodemailer)
* [Mailjet](https://github.com/novuhq/novu/tree/main/providers/mailjet)
* [Mandrill](https://github.com/novuhq/novu/tree/main/providers/mandrill)
* [SendinBlue](https://github.com/novuhq/novu/tree/main/providers/sendinblue)

### 📞 SMS

* [Twilio](https://github.com/novuhq/novu/tree/main/providers/twilio)
* [Plivo](https://github.com/novuhq/novu/tree/main/providers/plivo)
* [SNS](https://github.com/novuhq/novu/tree/main/providers/sns)
* [Nexmo - Vonage](https://github.com/novuhq/novu/tree/main/providers/nexmo)
* [Sms77](https://github.com/novuhq/novu/tree/main/providers/sms77)
* [Telnyx](https://github.com/novuhq/novu/tree/main/providers/telnyx)
* [Termii](https://github.com/novuhq/novu/tree/main/providers/termii)
* [Gupshup](https://github.com/novuhq/novu/tree/main/providers/gupshup)

### 📱 Push

* [FCM](https://github.com/novuhq/novu/tree/main/providers/fcm)
* [Expo](https://github.com/novuhq/novu/tree/main/providers/expo)
* [SNS](https://github.com/novuhq/novu/tree/main/providers/sns)

### 👇 Chat

* [Slack](https://github.com/novuhq/novu/tree/main/providers/slack)
* [Discord](https://github.com/novuhq/novu/tree/main/providers/discord)

### 📱 In-App

* [Novu](https://docs.novu.co/notification-center/getting-started)


# Roadmap
Source: https://v0.x-docs.novu.co/community/roadmap

Learn about our roadmap

<Card title="Novu's Roadmap" icon="map" href="https://roadmap.novu.co/roadmap">
  Learn about ongoing developments, upcoming plans, and items in our backlog..
</Card>

Your involvement in shaping the future of our notification infrastructure solution is highly encouraged.

## Get involved

**Submit Ideas:** If you have a new feature idea or an enhancement suggestion, don't hesitate to submit it through our [roadmap page](https://roadmap.novu.co/roadmap). Your creativity fuels our innovation!

**Upvote and Comment:** Review the existing feature requests and upvote the ones that resonate with you. Feel free to provide additional insights or use-cases through comments.

**Contribute:** If you're a developer, you can actively contribute to the development of the features in progress or even the backlog ones. [Join our community of contributors](https://discord.gg/novu?ref=docs-contribute) and help us bring these enhancements to life.

<Tip>Remember, this roadmap is a living document that evolves based on your input and the direction the community decides to take. Your voice matters, and we're excited to work together in building a robust notification infrastructure solution that meets everyone's needs.</Tip>


# Run Novu in local machine
Source: https://v0.x-docs.novu.co/community/run-in-local-machine

Prerequisites and steps to run Novu in local machine. Learn how to set up Novu on your local environment for testing and development.

[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/novuhq/novu)

### Requirements

* Node.js version v20.8.1
* MongoDB
* Redis
* **(Optional)** pnpm - Needed if you want to install new packages
* **(Optional)** localstack (required only in S3 related modules)

Need help installing the requirements? Read more [here](/community/machine-setup).

<Note>We recommend having at least 8GB of RAM to run Novu on a local machine as Novu has multiple services running together with external services like redis, mongodb etc.</Note>

<iframe />

### Setup the project

After installing the required services on your machine, you can clone and set up
your forked version of the project:

1. Clone the repository

<Tabs>
  <Tab title="Novu Org">
    ```shell theme={null}
    git clone https://github.com/novuhq/novu.git
    ```
  </Tab>

  <Tab title="Forked Repo">
    ```shell theme={null}
    git clone https://github.com/{YOUR_GITHUB_USER_NAME}/novu.git
    ```
  </Tab>
</Tabs>

2. Install all dependencies

```shell theme={null}
cd novu && npm run setup:project
```

3. Run the project

```shell theme={null}
npm run start
```

The `npm run start` will start the Jarvis CLI tool which allows you to run the whole project with ease. If you only want to run parts of the platform, you can use the following run commands from the root project:

* **start:dev** - Synonym to `npm run start`
* **start:web** - Only starts the web management platform
* **start:ws** - Only starts the WebSocket service for notification center updates
* **start:widget** - Starts the widget wrapper project that hosts the notification center inside an iframe
* **start:api** - Runs the API in watch mode
* **start:worker** - Runs the worker application in watch mode
* **start:dal** - Runs the Data Access Layer package in watch mode
* **start:shared** - Starts the watch mode for the shared client and API library
* **start:node** - Runs the `@novu/node` package in watch mode
* **start:notification-center** - Runs and builds the React package for the Novu notification center

<iframe />

<iframe />

### Set up your environment variables

If you have used Jarvis CLI tool from the previous step you don't need to setup the env variables as Jarvis will do that on the first run if setup wasn't done before.

The command `npm run setup:project` creates default environment variables that are required to run Novu in a development environment. However, if you want to test certain parts of Novu or run it in production mode, you need to change some of them. These are all the available environment variables:

<AccordionGroup>
  <Accordion title="API Backend">
    * `NODE_ENV` (default: local)The environment of the app. Possible values are: dev, test, production, ci, local
    * `S3_LOCAL_STACK`The AWS endpoint for the S3 Bucket required for storing various media
    * `S3_BUCKET_NAME`The name of the S3 Bucket
    * `S3_REGION`The AWS region of the S3 Bucket
    * `PORT`The port on which the API backend should listen on
    * `FRONT_BASE_URL`The base url on which your frontend is accessible for the user. (e.g. web.novu.co)
    * `DISABLE_USER_REGISTRATION` (default: false)If users should not be able to create new accounts. Possible values are: true, false
    * `REDIS_HOST`The domain / IP of your redis instance
    * `REDIS_PORT`The port of your redis instance
    * `REDIS_PASSWORD`Optional password of your redis instance
    * `REDIS_DB_INDEX`The Redis database index
    * `REDIS_CACHE_SERVICE_HOST`The domain / IP of your redis instance for caching
    * `REDIS_CACHE_SERVICE_PORT`The port of your redis instance for caching
    * `REDIS_CACHE_DB_INDEX`The Redis cache database index
    * `REDIS_CACHE_TTL`The Redis cache ttl
    * `REDIS_CACHE_PASSWORD`The Redis cache password
    * `REDIS_CACHE_CONNECTION_TIMEOUT`The Redis cache connection timeout
    * `REDIS_CACHE_KEEP_ALIVE`The Redis cache TCP keep alive on the socket timeout
    * `REDIS_CACHE_FAMILY`The Redis cache IP stack version
    * `REDIS_CACHE_KEY_PREFIX`The Redis cache prefix prepend to all keys
    * `REDIS_CACHE_SERVICE_TLS`The Redis cache TLS connection support
    * `IN_MEMORY_CLUSTER_MODE_ENABLED`The flag that enables the cluster mode. It might be Redis or ElastiCache cluster, depending on the env variables set for either service.
    * `ELASTICACHE_CLUSTER_SERVICE_HOST`ElastiCache cluster host
    * `ELASTICACHE_CLUSTER_SERVICE_PORT`ElastiCache cluster port
    * `REDIS_CLUSTER_SERVICE_HOST`Redis cluster host
    * `REDIS_CLUSTER_SERVICE_PORTS`Redis cluster ports
    * `REDIS_CLUSTER_DB_INDEX`Redis cluster database index
    * `REDIS_CLUSTER_TTL`Redis cluster ttl
    * `REDIS_CLUSTER_PASSWORD`Redis cluster password
    * `REDIS_CLUSTER_CONNECTION_TIMEOUT`Redis cluster connection timeout
    * `REDIS_CLUSTER_KEEP_ALIVE`Redis cluster TCP keep alive on the socket timeout
    * `REDIS_CLUSTER_FAMILY`Redis cluster IP stack version
    * `REDIS_CLUSTER_KEY_PREFIX`Redis cluster prefix prepend to all keys
    * `JWT_SECRET`The secret keybase which is used to encrypt / verify the tokens issued for authentication
    * `SENDGRID_API_KEY`The api key of the Sendgrid account used to send various emails
    * `MONGO_URL`The URL of your MongoDB instance
    * `MONGO_MAX_POOL_SIZE`The max pool size of the MongoDB connection
    * `NOVU_API_KEY`The api key of web.novu.co used to send various emails
    * `SENTRY_DSN`The DSN of sentry.io used to report errors happening in production
  </Accordion>

  <Accordion title="Worker">
    * `NODE_ENV` (default: local)The environment of the app. Possible values are: dev, test, production, ci, local
    * `PORT`The port on which the Worker app should listen on
    * `STORE_ENCRYPTION_KEY`The encryption key used to encrypt/decrypt provider credentials
    * `MAX_NOVU_INTEGRATION_MAIL_REQUESTS`The number of free emails that can be sent with the Novu email provider
    * `NOVU_EMAIL_INTEGRATION_API_KEY`The Novu email provider Sentry API key
    * `STORAGE_SERVICE`The storage service name: AWS, GCS, or AZURE
    * `S3_LOCAL_STACK`The LocalStack service URL
    * `S3_BUCKET_NAME`The name of the S3 Bucket
    * `S3_REGION`The AWS region of the S3 Bucket
    * `GCS_BUCKET_NAME`The name of the GCS Bucket
    * `AZURE_ACCOUNT_NAME`The name of the Azure account
    * `AZURE_ACCOUNT_KEY`The Azure account key
    * `AZURE_HOST_NAME`The Azure host name
    * `AZURE_CONTAINER_NAME`The Azure container name
    * `AWS_ACCESS_KEY_ID`The AWS access key
    * `AWS_SECRET_ACCESS_KEY`The AWS secret access key
    * `REDIS_HOST`The domain / IP of your redis instance
    * `REDIS_PORT`The port of your redis instance
    * `REDIS_PASSWORD`Optional password of your redis instance
    * `REDIS_DB_INDEX`The Redis database index
    * `REDIS_CACHE_SERVICE_HOST`The domain / IP of your redis instance for caching
    * `REDIS_CACHE_SERVICE_PORT`The port of your redis instance for caching
    * `REDIS_DB_INDEX`The Redis cache database index
    * `REDIS_CACHE_TTL`The Redis cache ttl
    * `REDIS_CACHE_PASSWORD`The Redis cache password
    * `REDIS_CACHE_CONNECTION_TIMEOUT`The Redis cache connection timeout
    * `REDIS_CACHE_KEEP_ALIVE`The Redis cache TCP keep alive on the socket timeout
    * `REDIS_CACHE_FAMILY`The Redis cache IP stack version
    * `REDIS_CACHE_KEY_PREFIX`The Redis cache prefix prepend to all keys
    * `REDIS_CACHE_SERVICE_TLS`The Redis cache TLS connection support
    * `IN_MEMORY_CLUSTER_MODE_ENABLED`The flag that enables the cluster mode. It might be Redis or ElastiCache cluster, depending on the env variables set for either service.
    * `ELASTICACHE_CLUSTER_SERVICE_HOST`ElastiCache cluster host
    * `ELASTICACHE_CLUSTER_SERVICE_PORT`ElastiCache cluster port
    * `REDIS_CLUSTER_SERVICE_HOST`Redis cluster host
    * `REDIS_CLUSTER_SERVICE_PORTS`Redis cluster ports
    * `REDIS_CLUSTER_DB_INDEX`Redis cluster database index
    * `REDIS_CLUSTER_TTL`Redis cluster ttl
    * `REDIS_CLUSTER_PASSWORD`Redis cluster password
    * `REDIS_CLUSTER_CONNECTION_TIMEOUT`Redis cluster connection timeout
    * `REDIS_CLUSTER_KEEP_ALIVE`Redis cluster TCP keep alive on the socket timeout
    * `REDIS_CLUSTER_FAMILY`Redis cluster IP stack version
    * `REDIS_CLUSTER_KEY_PREFIX`Redis cluster prefix prepend to all keys
    * `MONGO_URL`The URL of your MongoDB instance
    * `MONGO_MAX_POOL_SIZE`The max pool size of the MongoDB connection
    * `NEW_RELIC_APP_NAME`The New Relic app name
    * `NEW_RELIC_LICENSE_KEY`The New Relic license key
    * `SEGMENT_TOKEN`The Segment Analytics token
  </Accordion>

  <Accordion title="Web Client">
    * `REACT_APP_ENVIRONMENT` The environment of the app. Possible values are: dev, test, production, ci, local
    * `REACT_APP_API_URL` The base url on which your API backend would be accessible
    * `REACT_APP_WS_URL` The base url on which your WebSocket service would be accessible
    * `SKIP_PREFLIGHT_CHECK` (default: true)Solves a problem with React App dependency tree.

    <Warning>
      When configuring different than default values for the API and WebSocket URLs,
      in order for the Web app to apply the changes done to the `./env` file, it is
      needed to run the script `pnpm envsetup`. This will generate a file
      called `env-config.js` that will be copied inside of the `public` folder of
      the application. Its purpose is to inject in the `window._env_`object the
      chosen environment variables that manage the URLs the Web client will call to
      access to the API backend and the WebSocket service.
    </Warning>
  </Accordion>

  <Accordion title="Web Socket">
    * `NODE_ENV` (default: local)The environment of the app. Possible values are: dev, test, production, ci, local
    * `SENTRY_DSN`The DSN of sentry.io used to report errors happening in production
    * `REDIS_HOST`The domain / IP of your redis instance
    * `REDIS_PORT`The port of your redis instance
    * `REDIS_DB_INDEX`The database index of your redis instance
    * `REDIS_PASSWORD`Optional password of your redis instance
    * `JWT_SECRET`The secret keybase which is used to encrypt / verify the tokens issued for authentication
    * `MONGO_URL`The URL of your MongoDB instance
    * `MONGO_MAX_POOL_SIZE`The max pool size of the MongoDB connection
    * `PORT`The port on which the WebSocket service should listen on
  </Accordion>
</AccordionGroup>

### Running tests

After making changes, you can run the tests for the respective package using the appropriate CLI commands:

### API

To run the API tests, run the following command:

```shell theme={null}
npm run start:worker:test
npm run start:e2e:api
```

The tests create a new instance of Novu and a test db and run the tests against it. The test db is removed after all tests have finished running.

### Web

To run the front end tests for the web project using cypress you need to install localstack. The cypress tests perform E2E tests. To be able to perform E2E tests, you need to run the API service in the appropriate test environment.

Run the services in test env with the following commands:

```shell theme={null}
npm run start:web
npm run start:api:test
npm run start:worker:test
npm run start:ws:test
```

Run the cypress test suite with the following command:

```shell theme={null}
cd apps/web && npm run cypress:run
```

To open the cypress management window to debug tests, run the following commands:

```shell theme={null}
cd apps/web && npm run cypress:open
```

### Different ports used by the services

* **3000** - API
* **3002** - WebSocket Service
* **3003** - Webhook Service
* **3004** - Worker Service
* **4200** - Web Management UI
* **4701** - Iframe embed for notification center
* **4500** - Widget Service

### Testing providers

To run tests against the providers’ folder, you can use the `npm run test:providers` command.

### Local environment setup script (beta)

As an option in our script runner `Jarvis` we have made available an option to run [this script](https://github.com/novuhq/novu/blob/2f2abdcaaad8a7735e0a2d488607c3276c8975fd/scripts/dev-environment-setup.sh) that will automatically try to install all the dependencies needed to be able to run Novu locally, as the previous step of installing the project dependencies through `pnpm install`. When executing it inside `Jarvis`, you will need to have previously installed by yourself `git` and `node`, as we mentioned earlier on this page.

The script can be run on its own without any previous dependency installed, as it is prepared to execute the following tasks:

* Check the running OS in the local machine (currently only MacOSx and [GNU Linux](https://en.wikipedia.org/wiki/GNU/Linux_naming_controversy)supported)
* Install of OS dependencies (currently only MacOSx supported) -- MacOSx: It will execute the following tasks --- Will try to install or update [XCode](https://developer.apple.com/xcode/) (skippable step; though XCode installs `[git](https://git-scm.com/)` that is a required dependency for later) --- Will install [Rosetta](https://support.apple.com/en-gb/HT211861) for Apple CPUs --- Will set up some opinionated OS settings
* Will check if `[git](https://git-scm.com/)` is installed and if not will abort the operation
* Will make [ZSH](https://en.wikipedia.org/wiki/Z_shell) the default shell to be able to execute the next task
* Will (opinionatedly) install [Oh My Zsh!](https://ohmyz.sh/) (skippable task)
* Will (opinionatedly) install the [Homebrew](https://brew.sh/) package manager and will set up your local environment to execute it besides adding some casks
* Will (opinionatedly) install [NVM](https://github.com/nvm-sh/nvm) as a Node.js version manager
* Will install the required [Node.js](https://nodejs.org/en/) version to be able to [run Novu](https://github.com/novuhq/novu/blob/2f2abdcaaad8a7735e0a2d488607c3276c8975fd/package.json#L180)
* Will install [PNPM](https://pnpm.io/) as a package manager, required dependency for some of the tasks inside Novu's scripts
* Will install [Docker](https://www.docker.com/) as containerized application development tool
* Will install required databases [MongoDB](https://www.mongodb.com/) (Community version) and [Redis](https://redis.io/) through Homebrew
* Will install the [AWS CLI](https://aws.amazon.com/cli/) tool (not required to run Novu; it is a core maintainer used tool)
* Will create a local development domain `local.novu.co` in your local machine
* Will clone the Novu repository in your local machine (skippable step) to a selected folder `$HOME/Dev`

<Warning>
  This script has only been thoroughly tested in MacOSx. Little testing has been
  run in GNU Linux.
</Warning>

<Info>
  This script is not bullet-proof and some of the tasks have intertwined
  dependencies with each other. We have tried to make it as idempotent as
  possible but some loose knots will probably show because of conflicts between
  versions of the different dependencies. Please report to us any problem found
  and we will try to fix or assist though we do not have the resources to make
  it idempotent in every potential system and potential combinations
</Info>


# Windows
Source: https://v0.x-docs.novu.co/community/windows-machine-setup

Learn how to configure your local Windows machine to run Novu

## Setting up git

To set up git and create an access token for GitHub, suggested installing [GitHub Desktop](https://www.notion.so/Dev-Machine-Setup-98d274c80fa249b0b0be75b9a7a72acb?pvs=21) before.

## Development Environment

### Node & NVM

To easily manage multiple node versions you can use [NVM for Windows](https://github.com/coreybutler/nvm-windows) a (Node Version Manager alternative for Windows).

Download the .exe installation file for NVM for Windows [here](https://github.com/coreybutler/nvm-windows/releases).

After installing NVM for Windows, check that the installation is successfull and added to path by running `nvm -v` on a terminal.

<Note>
  After installing NVM, if you get `nvm: command not found` or see
  no feedback from your terminal after you type `nvm -v`, simply **close
  your current terminal, open a new terminal**, and try verifying again.
</Note>

Once nvm is installed and working you can install any version of Node using the syntax `nvm install vX.Y.Z` and to switch to a node version,
run `nvm use vX.Y.Z`. Novu requires node v20.8.1 or higher:

```shell theme={null}
nvm install v18.17.0
nvm use v18.17.0
```

### PNPM

For package management, we use [PNPM](https://pnpm.io/) instead of npm or yarn to speed up our install times and space efficiency. To install pnpm globally run:

```shell theme={null}
npm install -g pnpm
```

### MongoDB

for detailed instructions on installing MongoDB community edition on a Windows machine please refere to the MongoDB doc [here](https://www.mongodb.com/docs/manual/tutorial/install-mongodb-on-windows).

After installation, whether you have installed as a Windows service or just the binaries, ensure that the MongoDB instance is started before you proceed.

### Redis

To install Redis for local development you'll first need to enable WSL2 (Windows Subsystem for Linux). detailed instructions for installing
WSL can be found [here](https://learn.microsoft.com/en-us/windows/wsl/install)

If you have WSL installed and enabled, you can easily install Redis using the native procedure for the Linux distribution that you have installed.
for Ubuntu or Debian which is the default distro installed by WSL, use the following commands

1. First install `lsb-release`, `curl` and `gpg` if you do not already have them:

```shell theme={null}
sudo apt install lsb-release curl gpg
```

2. Add the repository to the apt index, update it, and then install:

```shell theme={null}
curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg

echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list

sudo apt-get update
sudo apt-get install redis
```

3. Lastly, start the Redis server like so:

```shell theme={null}
sudo service redis-server start
```

### Docker

Docker is not a requirement to run Novu on your local machine, but if you would prefer to use Docker, Follow the installation guide on [docker website](https://docs.docker.com/desktop/install/windows-install/) to install **Docker Desktop** on your Windows machine.

### AWS CLI

Follow the instructions to install the AWS CLI so you can use it to create env later on, based on existing S3 buckets:

[Installing or updating the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

You should get something like this:

<img alt="AWS CLI" />

If needed, see:

[Resolve "Unable to locate credentials" error in Amazon S3](https://aws.amazon.com/premiumsupport/knowledge-center/s3-locate-credentials-error/)

### Local dev domain (Optional)

This will allow you to use [local.novu.co](http://local.novu.co) instead of [localhost](http://localhost) when accessing the service on your machine.

Navigate to `C:\Windows\System32\drivers\etc` in the file explorer and open the `hosts` file with a text editor (like Notepad):

<Note>
  Note that this file can only be edited when running as an Administrator.
</Note>

And add the [local.novu.co](http://local.novu.co) domain and save.

```shell theme={null}
127.0.0.1       local.novu.co
```

### Code Editor

Feel free to install your favorite code editor. We supply licenses for [WebStorm](https://www.notion.so/WebStorm-7570ab1037bf494d88d0f9b544ae3b79?pvs=21), or you can [Visual Studio Code](https://code.visualstudio.com/download) if you prefer it.

### Productivity tools

* GitHub Desktop (Optional)

GitHub Desktop simplifies the development workflow and interaction with Git. [Download](https://desktop.github.com/) the client from their website.


# Bridge Endpoint
Source: https://v0.x-docs.novu.co/framework/concepts/endpoint



## Bridge Endpoint

Novu Framework requires a **single** `HTTP` endpoint (`/api/novu` or similar) to be exposed by your application. This endpoint is used to receive events from our Worker Engine.

You can view the Bridge Endpoint as a webhook endpoint that Novu will call when it needs to retrieve contextual information for a given subscriber and notification.

Using the `create-novu-app` command creates a Bridge application for you with a Bridge endpoint ready to go.

## The `serve` function

We offer framework specific wrappers in form of an exported `serve` function that abstracts away:

* Parsing the incoming request for `GET`, `POST`, `PUT` and `OPTIONS` requests
* HMAC header authentication
* Framework specific response and error handling

Currently, we offer `serve` functions for the following frameworks:

* [Next.js](/framework/sdk/frameworks/nextjs)
* [Express.js](/framework/sdk/frameworks/express)
* [Nuxt](/framework/sdk/frameworks/nuxt)
* [h3](/framework/sdk/frameworks/h3)
* [Remix](/framework/sdk/frameworks/remix)
* [Sveltekit](/framework/sdk/frameworks/sveltekit)

## Writing a custom `serve` function

If we currently don't support your framework, you can write a custom `serve` function like the following example:

```ts theme={null}
import { type Request, type Response } from 'express';
import { NovuRequestHandler, ServeHandlerOptions } from '@novu/framework';

export const serve = (options: ServeHandlerOptions): any => {
  const requestHandler = new NovuRequestHandler({
    frameworkName: 'express',
    ...options,
    handler: (
      incomingRequest: Request,
      response: Response,
    ) => ({
        method: () => incomingRequest.method,
        headers: (key) => {
            const header = incomingRequest.headers[key];
            return Array.isArray(header) ? header[0] : header;
        },
        queryString: (key) => {
                const qs = incomingRequest.query[key];
                return Array.isArray(qs) ? qs[0] : qs;
        },
        body: () => incomingRequest.body,
        url: () => new URL(incomingRequest.url, `https://${incomingRequest.headers.get("host") || ""}`),
        transformResponse: ({ body, headers, status }) => {
            Object.entries(headers).forEach(([headerName, headerValue]) => {
              response.setHeader(headerName, headerValue);
            });

            return response.status(status).send(body);
       },
    }),
  });

  return requestHandler.createHandler();
};
```


# Step Inputs
Source: https://v0.x-docs.novu.co/framework/concepts/inputs



Inputs are defined using [JSON Schema](/framework/recipes/json-schema), providing a strong run-time validation system for your workflows.

This ensures that you as the developer, and your non-technical peers are speaking the same language.
Those responsible for styling and copy can edit with confidence, knowing their changes are tested in code.

## Inputs vs Payload

**Inputs** - For Non-Technical Peers and Developers. Managed in the Novu Web UI, defined by developers and used by non-technical peers.

<Info>
  **Examples** - Color of a button, text of a button, should a section be shown, digest duration, static text content, the order of the email sections, and etc...
</Info>

**Payload Schema** - For Developers. Passed during the `novu.trigger` method, and controlled by the developer.

<Info>
  **Examples** - User ID, Post ID, Comment, Order ID, 2FA token and etc...
</Info>

## Step Inputs

[Step](/framework/concepts/steps) input schema is defining the input passed during the `step` method. Those inputs can be modified and persisted in the Novu Web UI.

The snippet below shows configuration for the Workflow payload schema and the Step input schema. If you don’t provide a schema, Typescript will infer the data type to `unknown`, reminding you of the best practice to specify your schema.

```tsx theme={null}
workflow('new-signup', async ({ step, payload }) => {
    await step.email(
      'send-email',
      async (inputs) => {
          return {
            subject: inputs.subjectTitle,
            body: render(<ReactEmailContent hideBanner={inputs.hideBanner} components={inputs.components} />),
        }
      }, {
	      // Learn about JSON Schema here: https://json-schema.org/specification
        inputSchema: {
	        // Always `object`
          type: 'object',
          // Specify the properties to validate. Supports deep nesting.
          properties: {
            hideBanner: { type: 'boolean', default: false },
            subjectTitle: { type: 'string' },
            // Allowing no code control over the component in the Web UI
            components: {
                type: "array",
                items: {
                    type: "string"
                },
                default: ["header", "cta-row", "footer"]
            }
          },
          // Specify the array of which properties are required.
          required: ['complianceFooter'],
          // Used to enforce full type strictness, with no rogue properties.
          additionalProperties: false,
		      // The `as const` is important to let Typescript know that this
		      // type won't change, enabling strong typing on `inputs` via type
		      // inference of the provided JSON Schema.
        } as const,
      });
});
```

Learn more about [JSON Schema here](https://json-schema.org/specification), including the powerful validation features to ensure your Content renders perfectly, every time.

<Note>
  Other validators, including Zod and more, coming soon.
  Any validator that supports transformation to JSON Schema can be added.
</Note>

## JSON Schema Examples

To Learn more about advanced examples, visit our [JSON Schema](/framework/recipes/json-schema) page.


# Payload
Source: https://v0.x-docs.novu.co/framework/concepts/payload



Workflow payload is the data passed during the `novu.trigger` method. This is useful for ensuring that the payload is correctly formatted and that the data is valid.

## Payload Schema

Payload schema is defining the payload passed during the `novu.trigger` method. This is useful for ensuring that the payload is correctly formatted and that the data is valid.

```tsx theme={null}
workflow('comment-on-post', async ({ step, payload }) => {
    await step.email(
      'send-email',
      async () => {
          return {
            subject: `You have a new comment from: ${payload.author_name}.`,
            body: render(<ReactEmailContent comment={payload.comment} />),
        }
      });
  },
  {
    payloadSchema: {
            // Always `object`
          type: 'object',
          // Specify the properties to validate. Supports deep nesting.
          properties: {
            post_id: { type: 'number' },
            author_name: { type: 'string' },
            comment: { type: 'string', maxLength: 200 },
          },
          // Specify the array of which properties are required.
          required: ['post_id', 'comment'],
          // Used to enforce full type strictness, with no rogue properties.
          additionalProperties: false,
		      // The `as const` is important to let Typescript know that this
		      // type won't change, enabling strong typing on `inputs` via type
		      // inference of the provided JSON Schema.
        } as const,
  },
);
```

## Passing Payload

Here is an example of the validated payload during trigger:

```tsx theme={null}
novu.trigger('comment-on-post', {
    to: 'subscriber_id',
    payload: {
        post_id: 1234,
        author_name: 'John Doe',
        comment: 'Looks good!'
    }
});
```


# Dev Studio
Source: https://v0.x-docs.novu.co/framework/concepts/studio



The Echo Dev Studio is a companion app to the Echo Client SDK. Its goal is to provide a local environment that lives near your code.

To launch the dev studio locally you can run: `npx novu-labs@latest echo` . The Dev Studio will be started by default on port 2022, and accessible via: `http://localhost:2022`

After successfully connecting the Studio to your local edge endpoint, you will be able to preview in real time any workflows and content defined in your code. This is ideal for quick prototyping, debugging, styling, and adjusting your workflows before syncing them to Novu Cloud.

### Inputs and Payload forms

You can quickly modify the step inputs and workflow payload to preview your workflow's different states and be generated with. This is helpful to quickly debug how the email will behave in case of a missing input, or iterate more complex content structures.

### Syncing State

Sync state to your Production or Development environment in Novu, is recommended to do via your CI pipeline. However, a sync can be made using the Dev Studio for quick experimentation.

Click on the `Sync` button at the top right corner of the navigation bar, and a Diff will be generated between your local and the Novu Cloud environments.

After inspecting the State Diff, and specifying the remote `Echo Url` Click on the `Deploy Changes` button.

### **Debugging locally**

To allow Novu to communicate with your local machine a tunnel will need to be generated. The quickest way to do it is with `localtunnel.` To Create a new tunnel in your terminal, type: `npx localtunnel --port <YOUR_EDGE_PORT>` . This command will return an https endpoint, which then can be used during the sync state flow described earlier.


# Workflows
Source: https://v0.x-docs.novu.co/framework/concepts/workflows

Workflows are at the core of responding to events in your system with notifications. Novu Framework enables you to declare type-safe, validated, and version-controlled Novu Workflows with code.

## Introduction

The most basic Workflow to send a notification in response to an event looks like:

```tsx theme={null}
import { workflow } from '@novu/framework';

const myWorkflow = workflow('new-signup', async ({ step, payload }) => {
	// Send a welcome email
  await step.email('send-email', async () => {
    return {
      subject: `Welcome to Acme, ${payload.name}`,
      body: 'We look forward to helping you achieve mission.',
    }
  });
  // JSON Schema for validation and type-safety. Zod, and others coming soon.
}, { payloadSchema: { properties: { name: { type: 'string' }}}} );
```

## Just-in-time data fetching

You can add any custom logic into your steps that you need. Maybe you’d like to fetch some information about your new sign-up from somewhere else during the Workflow execution. You can achieve it with the following changes:

```tsx theme={null}
const myWorkflow = workflow('new-signup', async ({ step, payload }) => {
	// Send a welcome email
  await step.email('send-email', async () => {
	  // Fetch the user from your database
	  const user = await db.getUser(payload.userId);
        return {
          subject: `Welcome to Acme ${user.productTier} tier, ${user.name}.`,
          // 'Welcome to Acme Business tier, John Doe.'
          body: 'We look forward to helping you achieve mission.',
        }
      });
      // Changing the schema from `name` -> `userId`, for type-safety.
    }, { payloadSchema: { properties: { userId: { type: 'string' }}}} );
```

We call this **just-in-time** notification data fetching. It allows you pull in data from the relevant sources during the Workflow execution, removing the need to store all of your subscriber data in Novu.

## Multi-step workflow

Now, what if you wanted to send another update to the same new user in 1 week? But, you don't want to send the follow-up if the User opted out. We can add more steps to the Workflow to achieve this.

```tsx theme={null}
const myWorkflow = workflow(
  'new-signup',
  async ({ step, payload }) => {
    await step.email('send-email', async () => {
      const user = await db.getUser(payload.userId);
      return {
        subject: `Welcome to Acme ${user.productTier} tier, ${user.name}.`,
        body: 'We look forward to helping you achieve mission.',
      };
    });

    // Wait for 1 week before continuing. After 1 week, Novu will continue
    // executing the Workflow from here.
    await step.delay('onboarding-follow-up', async () => ({
      amount: 1,
      type: 'regular',
      unit: 'weeks',
    }));

    // 1 week passed, let's follow up with an in-app notification.
    await step.inApp(
      'onboarding-follow-up',
      async (inputs) => {
        const user = await db.getUser(payload.userId);
        // The `feedbackUrl` can be updated in Novu Web without changing code.
        // This helps you to create re-usable Workflow snippets.
        return {
          body: `Hey ${user.name}! How do you like the product?

      Let us know <a href="${inputs.feedbackUrl}">here</a>
      if you have any questions.`,
        };
      },
      {
        // Don't follow up if the Subscriber opted out.
        skip: () => !payload.shouldFollowUp,
        // Add validation to ensure `feedbackUrl` provided in Web is a `uri`
        inputSchema: {
          type: 'object',
          properties: { feedbackUrl: { type: 'string', format: 'uri', default: 'https://acme.com/feedback' } },
          required: ['feedbackUrl'],
          additionalProperties: false,
        } as const,
      },
    );
  },
  {
    payloadSchema: {
      type: 'object',
      properties: {
        userId: { type: 'string' },
        shouldFollowUp: { type: 'boolean', default: true },
      },
      required: ['userId', 'shouldFollowUp'],
      additionalProperties: false,
    } as const,
  },
);
```

With this simple Workflow, we:

* Sent a new signup email
* Waited 1 week
* Sent an in-app follow-up notification

You should now have a grasp of the flexibility that Novu Framework offers.

Continue your reading in [Steps](/framework/concepts/steps) to find out the other channels and actions you can use with Novu Framework.

## Workflow Interface

```tsx theme={null}
workflow(
	// the Workflow name. Must be unique across your Bridge server.
	'new-signup',
	// Workflow resolver, the entry-point for your Workflow steps
	async ({
		// Helper function to declare your Workflow Steps.
		step,
		// Workflow Trigger payload
		payload,
	}) => {
	// ...your Workflow Steps

}, {
	// JSON Schema for validation and type-safety. Zod, and others coming soon.
	// https://json-schema.org/draft-07/json-schema-release-notes

	// The schema for the Workflow payload passed dynamically via Novu Trigger API
	// Defaults to an empty schema.
	payloadSchema: { properties: { name: { type: 'string' }}},
	// The schema for the Workflow inputs passed statically via Novu Web
	// Defaults to an empty schema.
	inputSchema: { properties: { brandColor: { type: 'string' }}},
});
```


# GitHub Actions
Source: https://v0.x-docs.novu.co/framework/deployment/actions



You can also deploy the workflow state with our built-in GitHub Action command:

```yaml theme={null}
name: Deploy Workflow State to Novu

on:
  push:
    branches:
      - main
jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2
		  - name: Sync State to Novu
		    uses: novuhq/actions-novu-sync@v0.0.4
		    with:
		      novu-api-key: ${{secrets.NOVU_API_KEY}} # Your Dev or Prod API Key to Novu
		      bridge-url: "" # This will be your target environment bridge url
```


# CLI
Source: https://v0.x-docs.novu.co/framework/deployment/cli



The Echo CLI provides a mechanism for you to synchronize your Workflows into Novu Cloud so that non-technical Novu Users can control the Workflow and Step-level inputs and enable your Workflows to be triggered via Novu API.

```bash theme={null}
npx novu-labs@latest sync --echo-url <YOUR URL> --api-key <NOVU_API_KEY>
```


# Going to Production
Source: https://v0.x-docs.novu.co/framework/deployment/production



Novu operates in a multi environment setup. Currently Novu Supports 2 environments:

* **Development** - This is the environment where the development team works on workflows.
* **Production** - This is the environment that is used to trigger workflows to your customers.

## Pushing changes to Cloud

Novu Framework operates in a GitOps model. This means that the source of truth for your workflows and configurations are located in your Git as Code.

The general workflow for pushing changes to Cloud is as follows:

* Create a feature branch
* Develop workflows locally in your Bridge application
* Sync changes to the Development environment to test e2e
* Merge the feature branch to your `dev` branch
  * This will trigger a CI/CD pipeline that will deploy the changes to the Development environment
* Test the changes in the Development environment
* Merge the `dev` branch to the `main` branch
  * This will trigger a CI/CD pipeline that will deploy the changes to the Production environment

## Networking

Novu Cloud workers will need to be able to communicated with your Bridge Endpoint. You will need to ensure that your firewall rules allow traffic from the internet.
Due to the autoscaling nature of Novu Cloud, we don't have a set of IP Addresses that you can whitelist.

## Security

Novu Cloud workers are GDPR, SOC2 type II and ISO 27001 compliant. We take security very seriously and have implemented a number of security measures to ensure that your data is safe.
Novu Framework has a builtin security mechanism that ensures that the requests are authentic from Novu Cloud using an HMAC signature.

HMAC Verification is turned on by default

```typescript theme={null}
export const client = new Client({
  apiKey: process.env.NOVU_API_KEY,,
  strictAuthentication: process.env.NODE_ENV !== "development", // set to true by default
});
```

<Info>
  For local development with Studio `strictAuthentication` should be set to `false`.
</Info>

The `X-Novu-Signature` header included in each signed event contains a timestamp and one or more signatures that we verify.
The timestamp is prefixed by t=, and each signature is prefixed by a scheme.
Schemes start with v, followed by an integer. Currently, the only valid live signature scheme is v1.

Handling the signature verification is done by the Novu Framework, you don't need to perform any action.

## CI/CD Integrations

Novu currently supports the following CI integrations:

* **GitHub Actions** - [Direct Integration](/framework/deployment/actions)
* **GitLab CI** - Using our [CLI command](/framework/deployment/cli)
* **Jenkins** - Using our [CLI command](/framework/deployment/cli)
* **CircleCI** - Using our [CLI command](/framework/deployment/cli)
* **Bitbucket Pipelines** - Using our [CLI command](/framework/deployment/cli)
* **Azure DevOps** - Using our [CLI command](/framework/deployment/cli)
* **Travis CI** - Using our [CLI command](/framework/deployment/cli)
* **Other** - For any other CI/CD tool, you can use our [CLI command](/framework/deployment/cli)

<Info>
  Direct integration with other CI/CD tools is on our roadmap. If you would like to see a specific CI/CD tool integrated, please reach out to us.
</Info>


# React E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/react-email



Integrating Novu Framework with [React.Email](https://react.email/) for your Next.js application can be done in three steps. If you don't have an app, you can create one with the `create-novu-app` command.

<Steps>
  <Step title="Install React.Email components">
    Install the required React.Email components.

    ```bash theme={null}
      npm i @react-email/components react-email
    ```
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.tsx` file for your email template.

    ```tsx theme={null}
    import * as React from "react";
    import { Button, Html } from "@react-email/components";

    function Email(props) {
      return (
        <Html>
          <Button
            href="https://example.com"
            style={{ background: "#000", color: "#fff", padding: "12px 20px" }}
          >
            Click me
          </Button>
        </Html>
      );
    }

    export function renderEmail(inputs) {
      return render(<Email {...inputs} />);
    }
    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```tsx theme={null}
    import { renderEmail } from './sample-email.tsx';
    import { workflow } from '@novu/framework';

    workflow('new-signup', async ({ step, payload }) => {
      await step.email('send-email', async (inputs) => {
        return {
          subject: `Welcome to React E-mail`,
          body: renderEmail(inputs),
        }
      });
    });
    ```
  </Step>
</Steps>


# Remix w/ React E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/remix-react-email



Integrating Novu Framework with [React email](https://react.email/) for your Remix application can be done in three steps. If you don't have an app, you can [clone our Remix example](https://github.com/novuhq/novu-framework-remix-example).

<Steps>
  <Step title="Install React email components">
    Install the required React email components.

    ```bash theme={null}
      npm i @react-email/components react-email
    ```
  </Step>

  <Step title="Create email templates folder">
    Create an `emails` folder in the `app` directory of your Remix app.
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.tsx` file for your email template.

    ```ts theme={null}
    import { Button, Html } from "@react-email/components";

    function Email(props) {
      return (
        <Html>
          <Button
            href="https://example.com"
            style={{ background: "#000", color: "#fff", padding: "12px 20px" }}
          >
            Click me
          </Button>
        </Html>
      );
    }

    export function renderEmail(inputs) {
      return render(<Email {...inputs} />);
    }
    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```tsx theme={null}
    import { renderEmail } from './sample-email.tsx';
    import { workflow } from '@novu/framework';

    workflow('new-signup', async ({ step, payload }) => {
      await step.email('send-email', async (inputs) => {
        return {
          subject: `Welcome to Remix and React E-mail`,
          body: renderEmail(inputs),
        }
      });
    });
    ```
  </Step>
</Steps>


# Svelte E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/svelte-email



Integrating Novu Framework with [Svelte email](https://react.email/) for your Svelte application can be done in three steps. If you don't have an app, you can [clone our Svelte example](https://github.com/novuhq/novu-svelte-email).

<Steps>
  <Step title="Install Svelte email components">
    Install the required Svelte email components.

    ```bash theme={null}
      npm i svelte-email
    ```
  </Step>

  <Step title="Create email templates folder">
    Create an `emails` folder in the `src/lib` directory of your Svelte app.
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.svelte` file for your email template.

    ```ts theme={null}
    <script lang="ts">
        import { Button, Container, Head, Hr, Html, Img, Preview, Section, Text } from 'svelte-email';

        export let firstName = 'John';

        const fontFamily =
            '-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen-Sans,Ubuntu,Cantarell,"Helvetica Neue",sans-serif';

        const main = {
            backgroundColor: '#ffffff'
        };

        const container = {
            margin: '0 auto',
            padding: '20px 0 48px'
        };

        const logo = {
            margin: '0 auto'
        };

        const paragraph = {
            fontFamily,
            fontSize: '16px',
            lineHeight: '26px'
        };

        const btnContainer = {
            textAlign: 'center' as const
        };

        const button = {
            fontFamily,
            backgroundColor: '#5F51E8',
            borderRadius: '3px',
            color: '#fff',
            fontSize: '16px',
            textDecoration: 'none',
            textAlign: 'center' as const,
            display: 'block'
        };

        const hr = {
            borderColor: '#cccccc',
            margin: '20px 0'
        };

        const footer = {
            fontFamily,
            color: '#8898aa',
            fontSize: '12px'
        };
    </script>

    <Html lang="en">
        <Head />
        <Preview preview="Welcome to svelte-email" />
        <Section style={main}>
            <Container style={container}>
                <Img
                    src="https://svelte.dev/svelte-logo-horizontal.svg"
                    alt="Svelte logo"
                    style={logo}
                    width="200"
                    height="50"
                />
                <Text style={paragraph}>{firstName}, welcome to svelte-email</Text>
                <Text style={paragraph}>A Svelte component library for building responsive emails</Text>
                <Section style={btnContainer}>
                    <Button pX={12} pY={12} style={button} href="https://github.com/carstenlebek/svelte-email">
                        View on GitHub
                    </Button>
                </Section>
                <Text style={paragraph}>Happy coding!</Text>
                <Hr style={hr} />
                <Text style={footer}>Carsten Lebek</Text>
            </Container>
        </Section>
    </Html>
    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```tsx theme={null}
    import WelcomeEmail from '$lib/emails/sample-email.svelte';
    import { render } from 'svelte-email';
    import { workflow } from '@novu/framework';

    workflow('new-signup', async ({ step, payload }) => {
        await step.email(
            'send-email',
            async (inputs) => {
                const html = render({
                    template: WelcomeEmail,
                    props: {
                        firstName: 'John',
                    },
                });
                return {
                    subject: `Welcome to Svelte E-mail`,
                    body: html,
                }
            });
        }
    );
    ```
  </Step>
</Steps>


# Vue E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/vue-email



You can integrate Novu Framework with [Vue Email](https://vuemail.net/) in a few simple steps. This guide will walk you through the process of creating a new email template using Vue Email and Nuxt.

For a Quickstart Boilerplate project using Nuxt.js, and Vue Email, check out the [Vue Email Starter repository](https://github.com/novuhq/novu-framework-nuxt-example/)

## Quickstart

<Steps>
  <Step title="Install Vue.Email components">
    Install the required Vue.Email components.

    ```bash theme={null}
    npm install vue-email @vue-email/compiler @vue-email/nuxt
    ```
  </Step>

  <Step title="Create templates folder">
    Create a `templates` folder in the root of your Nuxt app
  </Step>

  <Step title="Update nuxt.config.ts File">
    Update your `nuxt.config.ts` file to include the Vue Email module.

    ```ts nuxt.config.ts theme={null}
    export default defineNuxtConfig({
        devtools: { enabled: true },
        components: true,

        modules: [
            '@vue-email/nuxt',
        ],
    })
    ```
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.vue` file in the `templates` folder for your email template.

    ```vue theme={null}
    <script setup lang="ts">
        import { defineProps, withDefaults } from 'vue'

        interface Props {

        }

        const baseUrl = "https://react-email-demo-bdj5iju9r-resend.vercel.app";

        const props = withDefaults(defineProps<Props>(), {});
    </script>

    <template>
        <ETailwind>
            <EHtml>
                <EHead/>
                <EPreview>Email Preview Text</EPreview>
                <EBody class="bg-white my-auto mx-auto font-sans">
                    <EContainer class="border border-solid border-[#eaeaea] p-[20px] md:p-7 rounded my-[40px] mx-auto max-w-[465px]">
                        <EHeading class="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
                            Hello World!
                        </EHeading>
                    </EContainer>
                </EBody>
            </EHtml>
        </ETailwind>
    </template>

    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```ts theme={null}
    import { config } from '@vue-email/compiler';
    import { workflow } from '@novu/framework';

    const vueEmail = config('templates', {
        verbose: false,
        options: {},
    });


    workflow('new-signup', async ({step, payload}) => {
        await step.email('send-email', async (inputs) => {
            const template = await vueEmail.render('sample-email.vue', {
                props: inputs
            })

            return {
                subject: `Welcome to Vue E-mail`,
                body: template.html
            }
        });
    });
    ```
  </Step>
</Steps>

## Learn More

To learn more, refer to [Vue Email documentation](https://vuemail.net/).


# No-Code Tools to control your Notification Flows
Source: https://v0.x-docs.novu.co/framework/non-developers/introduction

Change notification content and behavior with confidence using Novu Web UI.

Novu Framework was designed to bridge the gap between developers and on-developers in the team.

* **Developers** - Define and abstract away complex logic, data manipulation and hydration, html and etc...
* **Non-Developers** - Use the Novu Web UI to control the content and behavior of the notifications using [Inputs](/framework/concepts/inputs).

## How to Modify Inputs?

Inputs are modified directly on the [Novu Web UI](https://web.novu.co). Each Workflow editor page have an 'Inputs' tab where you can modify them.
When Saving the changes, the new Input values will be used in the notification sent to your subscriber.

## Common Input Usecases

### Change Notification Content

An input can be as broad as `content` or as specific as `2fa_code_title_color`. This allows you to change the content of the notification without needing to touch the code.

<Tip>
  Currently you cannot use Dynamic payload variables as part of the Input. Reach out to us if you need this capability.
</Tip>

### Change Digest or Delay Frequency

Inputs can be used for controlling any aspect of the step configuration, for example:

* Digest Length
* Delay Amount
* Digest Type (Daily, Weekly, Monthly)
* etc...

### Control structure and layout

Inputs can be used to show/hide or rearrange the layout of the notification.
For example, you can have an input to show/hide a button, or change the position of a specific email section.


# Quick Start
Source: https://v0.x-docs.novu.co/framework/quickstart

Novu Framework, the Code-first notification workflow engine. Build advanced workflows while giving your non-technical teammates complete control over content and behavior.

<Note>
  **Novu Framework is currently in public Alpha.** Need help? Have a suggestion? Join our [Discord community](https://discord.gg/novu).
</Note>

## Introduction to Novu Framework

Novu Framework allows you to write notification workflows in your codebase. Workflows are functions that execute business logic and use your preferred libraries for email, SMS, and chat generation. You can use Novu Framework with [React.Email](https://react.email/), [MJML](https://mjml.io/), or any other template generator.

<EchoTerminal />

## Try it now

To create a new Bridge application that will allow you to define your workflow in code, open your terminal and execute the `create-novu-app` command.

```shell theme={null}
npx create-novu-app@latest --api-key=<API_KEY_HERE>
```

The command will ask you if you wish to install from a React.Email template or a clean project.

## Core features

<CardGroup>
  <Card title="Bring Your Own Code" icon="code">
    Write the notification workflows as functions in your codebase,  version, and manage them using Git.
  </Card>

  <Card title="Limitless Integrations" icon="plug" href={'/framework/integrations'}>
    Use React.email, MJML, or fetch templates from Braze, Hubspot, Sendgrid, and more...
  </Card>

  <Card title="Type Safety" icon="shield">
    Bring your own schemas for full, end-to-end validation and type safety.
  </Card>

  <Card title="Cloud Synchronization" icon="cloud">
    Sync your workflows with Novu Cloud and ease collaboration.
  </Card>
</CardGroup>

## How it Works?

Novu Framework introduces a new paradigm when working with Novu. Rather than defining workflows and templates at Novu Cloud, Novu Framework enables you to work in your application, use your own libraries and connect to your production environment during workflow execution over HTTPS.

The Novu Framework exports the client you use to define and serve your workflows and their steps over HTTPS. The workflows can be added to your preferred framework. During workflow execution Novu Cloud makes HTTPS requests to your Bridge server for *just-in-time* Content and Subscribers resolution.

<Frame>
  <img />
</Frame>

## For Non-Technical Users

Novu Framework was built with non-technical user in mind. Engineers can write complex workflows and expose a type-safe [Inputs](/framework/concepts/inputs) interface powered by JSON-Schema.
This enables Non-Technical teammates to safely modify the workflow without breaking mission critical notifications.


# JSON Schema
Source: https://v0.x-docs.novu.co/framework/recipes/json-schema



JSON Schema can be used to define the [Workflow Payload](/framework/concepts/inputs) and [Step Inputs](/framework/concepts/inputs).
It provides a strongly-typed way to define the structure of the data that is expected by the Workflow or Step.
And also as a contract for changing the Workflow behaviour using the Platform User Interface.

Learn more about JSON Schema at [json-schema.org](https://json-schema.org/).

## Examples

### Simple

```json theme={null}
{
  "type": "object",
  "required": [
    "firstName",
    "lastName"
  ],
  "properties": {
    "firstName": {
      "type": "string",
      "title": "First name",
      "default": "Chuck"
    },
    "lastName": {
      "type": "string",
      "title": "Last name"
    },
    "age": {
      "type": "integer",
      "title": "Age"
    }
  }
}
```

### Nested Array Structure

```json theme={null}
{
  "type": "object",
  "required": [
    "title"
  ],
  "properties": {
    "title": {
      "type": "string",
      "title": "Task list title"
    },
    "tasks": {
      "type": "array",
      "title": "Tasks",
      "items": {
        "type": "object",
        "required": [
          "title"
        ],
        "properties": {
          "title": {
            "type": "string",
            "title": "Title",
            "description": "A sample title"
          },
          "details": {
            "type": "string",
            "title": "Task details",
            "description": "Enter the task details"
          },
          "done": {
            "type": "boolean",
            "title": "Done?",
            "default": false
          }
        }
      }
    }
  }
}
```

### Reference and Reuse Blocks

```json theme={null}
{
  "definitions": {
    "address": {
      "type": "object",
      "properties": {
        "street_address": {
          "type": "string"
        },
        "city": {
          "type": "string"
        },
        "state": {
          "type": "string"
        }
      },
      "required": [
        "street_address",
        "city",
        "state"
      ]
    },
    "node": {
      "type": "object",
      "properties": {
        "name": {
          "type": "string"
        },
        "children": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/node"
          }
        }
      }
    }
  },
  "type": "object",
  "properties": {
    "billing_address": {
      "title": "Billing address",
      "$ref": "#/definitions/address"
    },
    "shipping_address": {
      "title": "Shipping address",
      "$ref": "#/definitions/address"
    },
    "tree": {
      "title": "Recursive references",
      "$ref": "#/definitions/node"
    }
  }
}
```

### Any Of Schemas

```json theme={null}
{
  "type": "object",
  "properties": {
    "age": {
      "type": "integer",
      "title": "Age"
    },
    "items": {
      "type": "array",
      "items": {
        "type": "object",
        "anyOf": [
          {
            "properties": {
              "foo": {
                "type": "string"
              }
            }
          },
          {
            "properties": {
              "bar": {
                "type": "string"
              }
            }
          }
        ]
      }
    }
  },
  "anyOf": [
    {
      "title": "First method of identification",
      "properties": {
        "firstName": {
          "type": "string",
          "title": "First name",
          "default": "Chuck"
        },
        "lastName": {
          "type": "string",
          "title": "Last name"
        }
      }
    },
    {
      "title": "Second method of identification",
      "properties": {
        "idCode": {
          "type": "string",
          "title": "ID code"
        }
      }
    }
  ]
}
```

### One Of Schema

```json theme={null}
{
  "type": "object",
  "oneOf": [
    {
      "properties": {
        "lorem": {
          "type": "string"
        }
      },
      "required": [
        "lorem"
      ]
    },
    {
      "properties": {
        "ipsum": {
          "type": "string"
        }
      },
      "required": [
        "ipsum"
      ]
    }
  ]
}
```

### If Then Else

```json theme={null}
{
  "type": "object",
  "properties": {
    "animal": {
      "enum": [
        "Cat",
        "Fish"
      ]
    }
  },
  "allOf": [
    {
      "if": {
        "properties": {
          "animal": {
            "const": "Cat"
          }
        }
      },
      "then": {
        "properties": {
          "food": {
            "type": "string",
            "enum": [
              "meat",
              "grass",
              "fish"
            ]
          }
        },
        "required": [
          "food"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "animal": {
            "const": "Fish"
          }
        }
      },
      "then": {
        "properties": {
          "food": {
            "type": "string",
            "enum": [
              "insect",
              "worms"
            ]
          },
          "water": {
            "type": "string",
            "enum": [
              "lake",
              "sea"
            ]
          }
        },
        "required": [
          "food",
          "water"
        ]
      }
    },
    {
      "required": [
        "animal"
      ]
    }
  ]
}
```

### Enum Objects

```json theme={null}
{
  "definitions": {
    "locations": {
      "enumNames": [
        "New York",
        "Amsterdam",
        "Hong Kong"
      ],
      "enum": [
        {
          "name": "New York",
          "lat": 40,
          "lon": 74
        },
        {
          "name": "Amsterdam",
          "lat": 52,
          "lon": 5
        },
        {
          "name": "Hong Kong",
          "lat": 22,
          "lon": 114
        }
      ]
    }
  },
  "type": "object",
  "properties": {
    "location": {
      "title": "Location",
      "$ref": "#/definitions/locations"
    },
    "locationRadio": {
      "title": "Location Radio",
      "$ref": "#/definitions/locations"
    },
    "multiSelect": {
      "title": "Locations",
      "type": "array",
      "uniqueItems": true,
      "items": {
        "$ref": "#/definitions/locations"
      }
    },
    "checkboxes": {
      "title": "Locations Checkboxes",
      "type": "array",
      "uniqueItems": true,
      "items": {
        "$ref": "#/definitions/locations"
      }
    }
  }
}
```

### Regex Validation

The following example matches a simple North American telephone number with an optional area code:

```json theme={null}
{
  "type": "object",
  "properties": {
    "phone": {
      "type": "string",
      "pattern": "^(\\([0-9]{3}\\))?[0-9]{3}-[0-9]{4}$"
    }
  }
}
```

## Other Resources

* [Examples](https://json-schema.org/learn/miscellaneous-examples)
* [React JSON Schema](https://rjsf-team.github.io/react-jsonschema-form/)
* [JSON Schema Validator](https://www.jsonschemavalidator.net/)
* [JSON Schema Lint](https://jsonschemalint.com/)


# Roadmap
Source: https://v0.x-docs.novu.co/framework/roadmap



This document outlines the roadmap for the Novu Framework project. It is a living document and will be updated as the project progresses.

Our goal with Novu Framework is to create a Code-First but Product in-mind. Here you can see parts of our roadmap and future plans for it:

Looking to add a feature request or upvote and existing feature? Head over to our [Public Roadmap](https://roadmap.novu.co).

## Novu Framework, Now and Next

* ✅ **Workflows**: the ability to create multi-step workflows and manage them using Code.
* ✅ **CLI**: a command-line interface to interact with Novu Framework.
* ✅ **Studio**: a visual front to preview your local work.
* ✅ **Step Inputs**: JSON-Schema based interface for not technical users to modify the workflow content and behaviour.
* ✅ **GitHub Actions**: sync your workflows using GitHub Actions.
* ✅ **In App Seen/Read**: the ability to see the status of the in-app message.
* ✅ **Custom Step**: the ability to create custom and execute custom code in the workflow. For example: custom provider, retrieving database information, and 3rd party service integration.
* 🔜 **Zod Schema**: the ability to define the schema for the workflow and step inputs using Zod.
* 🔜 **Define Integrations**: code-first approach of creating and managing your provider integrations
* 🔜 **Email Reply Hook**: executing a custom logic code when a user replies to the email.
* 🔜 **Webhook**: receive webhooks about the execution flow of a workflow in Novu Framework.
* 🔜 **Eslint Plugin**: follow best practices and avoid common mistakes when writing code for Novu Framework.
* 🔜 **Codegen**: use our community driven list of workflow templates to use out of the box.


# Introduction
Source: https://v0.x-docs.novu.co/framework/sdk/client



See the snippet below to learn how to configure your Bridge endpoint application.

```tsx theme={null}
import { Client } from '@novu/framework';

const client = new Client({
  /**
   * Specify a custom Novu API URL.
   * Defaults to 'https://api.novu.co', for EU use: https://eu.api.novu.co
   */
	apiUrl: 'https://api.novu.co',
  /**
   * Specify your Novu API key, to secure your Bridge API endpoint.
   * Novu communicates securely with your endpoint using a signed HMAC header,
   * ensuring that only trusted requests from Novu are actioned by your Bridge API.
   * The API key is used to sign the HMAC header.
   */
	apiKey: process.env.NOVU_API_KEY,
  /**
   * Explicitly use HMAC signature verification.
   * Setting this to `false` will enable Novu to communicate with your Bridge API
   * without requiring a valid HMAC signature.
   * This is useful for local development and testing.
   *
   * You are strongly encouraged to specify an `apiKey` and set this to `true` in production,
   * to ensure that only trusted requests from Novu are actioned by your Bridge API.
   *
   * Defaults to true.
   */
	strictAuthentication: process.env.NODE_ENV !== "development",
});
```


# Integrate Novu with Express.js
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/express



```tsx theme={null}
import { serve } from "@novu/framework/express";
import { myWorkflow } from "../novu/workflows";

app.use(express.json()); // Required for Novu POST requests
app.use(
  "/api/novu",
  serve({ workflows: [myWorkflow] })
);
```


# Integrate Novu with H3
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/h3



```tsx theme={null}
import { createApp, eventHandler, toNodeListener } from "h3";
import { serve } from "@novu/framework/h3";
import { createServer } from "node:http";
import { myWorkflow } from "./novu/workflows";

const app = createApp();
app.use(
  "/api/novu",
  eventHandler(
    serve({
      workflows: [myWorkflow],
    })
  )
);

createServer(toNodeListener(app)).listen(process.env.PORT || 3000);
```


# Integrate Novu with Next.js
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/nextjs



## App Router

<CodeGroup>
  ```ts app/api/novu/route.ts theme={null}
  import { serve } from "@novu/framework/next";
  import { myWorkflow } from "../../novu/workflows";

  export const { GET, POST, PUT, OPTIONS } = serve({ workflows: [myWorkflow] });
  ```
</CodeGroup>

## Pages Router

<CodeGroup>
  ```ts pages/api/novu.ts theme={null}
  import { serve } from "@novu/framework/next";
  import { myWorkflow } from '../../novu/workflows';

  export default serve({ workflows: [myWorkflow] });
  ```
</CodeGroup>

Check out a comprehensive [guide on sending notifications in Next.js with React email](/guides/framework-guides/framework-react-email).


# Integrate Novu with Nuxt
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/nuxt



Novu Framework works out of the box with Nuxt.js. You can use the `@novu/framework/nuxt` package to serve your Bridge endpoint in your Nuxt.js application.

For a boilerplate project with Vue Email, view: [Nuxt.js Boilerplate](https://github.com/novuhq/novu-framework-nuxt-example/)

<CodeGroup>
  ```ts API Routes theme={null}
  import { serve } from "@novu/framework/nuxt";
  import { myWorkflow } from "../workflows";

  export default defineEventHandler(serve({ workflows: [myWorkflow] }));
  ```
</CodeGroup>

Check out a comprehensive [guide on sending notifications in Nuxt with Vuemail](/guides/framework-guides/framework-nuxt-vuemail).


# Integrate Novu with Remix
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/remix



```tsx theme={null}
import { serve } from "@novu/framework/remix";
import { myWorkflow } from "../novu/workflows";

const handler = serve({
    workflows: [myWorkflow],
  });
  
export { handler as action, handler as loader };
```

Check out a comprehensive [guide on sending notifications in Remix with React email](/guides/framework-guides/framework-remix).


# Integrate Novu with SvelteKit
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/sveltekit



```tsx theme={null}
import { myWorkflow } from '../workflows';
import { serve } from '@novu/framework/sveltekit';

export const { GET, POST, PUT } = serve({ workflows: [myWorkflow] });
```

Check out a comprehensive [guide on sending notifications in Svelte with Svelte-email](/guides/framework-guides/framework-svelte).


# Typescript
Source: https://v0.x-docs.novu.co/framework/sdk/typescript



Novu Framework was built and optimized for extreme focus on Developer Experience.
Our `@novu/framework` SDK is written in Typescript, and we recommend using Typescript for your own projects as well.

<EchoTerminal />

## Type Safe Workflow Payloads

When defining a [workflow payload](/framework/concepts/payload) schema, our SDK will automatically infer it to a Typescript interface.

```typescript theme={null}
import { workflow } from '@novu/framework';

const myWorkflow = workflow('new-signup', async ({ step, payload }) => {
	await step.email('send-email', () => {
        return {
            subject: 'Hello World',
            // The payload object here is type-safe
            body: `Hi ${payload.name}, welcome to our platform!`
        }
	});
}, {
	// JSON Schema for validation and type-safety. Zod, and others coming soon.
	// https://json-schema.org/draft-07/json-schema-release-notes
	payloadSchema: { properties: { name: { type: 'string' }}},
});
```

## Type Safe Steps

Similarly, when defining a [step](/framework/concepts/steps) schema, our SDK will automatically infer it to a Typescript interface.


# Chat Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/chat



Use the chat channel step to send a message for providers like: Slack, WhatsApp, Discord and others.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
});
```

## Provider Overrides

Some providers offer a rich DSL for styling the messages. Novu Framework offers a robust API to leverage the provider specific capabilities using the step `providers` option object.

Let's see an example of how to send a message to Slack using the `providers` option objet.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
}, {
    providers: {
        slack: ({ inputs }) => ({
            text: 'A new post has been created',
            blocks: [
                {
                    type: 'section',
                    text: {
                        type: 'mrkdwn',
                        text: 'A new post has been created',
                    },
                },
            ],
        }),
    }
});
```

Default chat `body` field is still specified as a fallback value in case a provider specific configuration is not used.

<Info>
  Currently we only support `Slack` provider overrides. We are working on adding more providers.
</Info>


# Custom Action Step
Source: https://v0.x-docs.novu.co/framework/steps/custom

Used to execute any custom code as a step in the workflow.

A custom steps allows to execute any custom logic and persist in the durable execution context. The result of this step can be used in subsequent steps.

## Common usecases

* Making an API call to 3rd party service
* Fetch data from a database to be used in subsequent steps
* Execute a custom logic to transform data
* Custom provider implementation

## Custom Step Interface

```tsx theme={null}
const stepResult = await step.custom('custom-step', async () => {
  return {
    item_name: 'A product name',
    item_price: 100,
  };
}, {
    outputSchema: {
        type: 'object',
        properties: {
            item_name: { type: 'string' },
            item_price: { type: 'number' },
        },
        required: ['item_name', 'item_price'],
    }
});
```

### Output Schema Definition

This JSON Schema definition is used to validate the output of the custom step. If the output does not match the schema, the workflow will fail.
Novu Framework will infer the Typescript interface from the JSON Schema definition.

### Return Value

The Custom Step function should return a valid serializable object. The return value will be persisted in the durable execution context.

## Using the Custom Step Result

The result can only be used in the `resolver` of the step/providers/skip functions of subsequent steps.

```typescript theme={null}
workflow('hello-world-workflow', async ({ payload }) => {
    const task = await step.custom('fetch-db-data', async () => {
        const taskData = db.fetchTask(payload.task_id);
        return {
            task_id: taskData.id,
            task_title: taskData.title,
            complete: taskData.complete,
        };
    }, {
        outputSchema: {
            type: 'object',
            properties: {
                task_title: { type: 'string' },
                task_id: { type: 'string' },
                complete: { type: 'boolean' },
            },
            required: ['task_id', 'complete'],
        }
    });

    await step.email('send-email', () => {
        return {
            subject: `Task reminder for ${task.task_title}`,
            body: 'Task is not yet complete. Please complete the task.'
        }
    }, {
        // Only send the reminder E-mail if the task is not complete
        skip: () => !task.complete
    })
});



```


# Delay Action Step
Source: https://v0.x-docs.novu.co/framework/steps/delay



Use the delay action whenever you need to pause the execution of your workflow for a period of time.

```tsx theme={null}
await step.delay('delay-1-week', async () => {
  return {
	  unit: 'weeks', // 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
	  amount: 1, // the number of units to delay workflow execution for
	};
});
```


# Digest Action Step
Source: https://v0.x-docs.novu.co/framework/steps/digest



The digest engine is designed to streamline notifications by accumulating multiple trigger events into one coherent message before delivery to the subscriber.

This function proves beneficial when a user needs to be alerted about numerous triggers, but it's important to minimize the frequency of notifications. Novu automates this process, batching incoming trigger events according to a unique subscriberId. There is also the option to include a digestKey, providing additional control over event digestion workflows.

## Step Interface

```tsx theme={null}
const digestResult = await step.digest('digest-3-days', async () => {
  return {
	  unit: 'days', // 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
	  amount: 3, // the number of units to digest events for
	};
});
```

## Using the digested triggers

The digest function returns an array of triggers that have been digested.
You can use this array to perform any necessary actions on the digested triggers. Like Sending and email, or updating a database.

```tsx theme={null}
const digestResult = await step.digest('digest-3-days', async () => {
  return {
	  unit: 'days', // 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
	  amount: 3, // the number of units to digest events for
	};
});

await step.email('send-email', async () => {
  return {
    subject: 'Digest Email',
    body: `You have ${digestResult.events.length} new events`,
 };
});
```

The digest step returns an object with `events` array. Each event in the array has the following properties:

* `id` - The `job id` of the digested event
* `time` - The time when the event was triggered
* `payload` - The original payload passed to the event


# Email Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/email



E-mail expected to be an object with the following properties:

* `subject` - The subject of the email
* `body` - The HTML body of the email

Any content generation framework like [React Email](/framework/integrations/react-email) can be used here to generate the HTML Content.

```tsx theme={null}
await step.email('send-email', async (inputs) => {
  return {
    subject: 'You received a post',
    body: `<html><body>A new post has been created</body></html>`,
  };
});
```


# In-App Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/in-app



Novu offers notification center component that can be easily embedded into your application. Read more about it [here](/notification-center/introduction).

```tsx theme={null}
await step.inApp('send-in-app', async (inputs) => {
  return {
    body: `A new post has been created`,
  };
});
```


# Workflow Steps
Source: https://v0.x-docs.novu.co/framework/steps/introduction

Steps control the execution flow of your workflow, whilst Novu provides the context of your notification delivery events back into the Workflow execution context.

## Supported Steps

Novu Supports Channel and Action steps to be used as part of the workflow execution.

### Channel Steps

* [E-mail](/framework/steps/email)
* [Chat](/framework/steps/chat)
* [SMS](/framework/steps/sms)
* [Push](/framework/steps/push)
* [In-App](/framework/steps/in-app)

### Action steps

* [Delay](/framework/steps/delay)
* [Digest](/framework/steps/digest)

## Channel Steps Interface

Channel steps are used to send notifications to your Subscribers. Each channel can optionally configure the provider to customize content, enabling you to create enhanced content aligned with the specification of the provider. For example, you might like to use Slack blocks to send your Chat message.

All channels follow the same interface:

```tsx theme={null}
await step.email('new-post', async (inputs) => {
    return {
        subject: 'You received a post',
        body: `<html><body>A new post has been created</body></html>`,
    }
}, options);
```

* `new-post` is the unique to the workflow identifier for this step. You cannot have 2 steps using the same identifier
* `resolver` function, used to return the content of the channel.
* `options` this is an optional configuration object that defines: [Input Schema](/framework/concepts/inputs), [Provider Overrides](#provider-overrides), skip and other configurations...

## Provider Overrides

Provider overrides are used to customize the content of the notification for a specific provider. For example, you might like to use Slack blocks to send your Chat message.

Those overrides are mapped directly to the provider specific SDKs, so you can use the same properties and methods that you would use in the provider SDK.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
}, {
    providers: {
        slack: ({ inputs }) => ({
            text: 'A new post has been created',
            blocks: [
                {
                    type: 'section',
                    text: {
                        type: 'mrkdwn',
                        text: 'A new post has been created',
                    },
                },
            ],
        }),
    }
});
```

<Info>
  Currently we only support `Slack` provider overrides. We are working on adding more providers.
</Info>

When overriding a provider specific behavior, Novu still requires the default content to be returned from the resolver function.
This is because the default content is used for the fallback provider, or when the provider override is not available.

## Skip Step

A step can be conditionally skipped by returning `true` from the resolver function. This is helpful when you want to use your existing user-preference system instead of Novu.
Or conditionally skip a step if it's not relevant any more for delivery.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
}, {
    skip: () => true,
});
```


# Push Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/push



```tsx theme={null}
await step.push('send-push', async () => {
  return {
    subject: 'You received a post',
    body: 'A new post has been created',
  };
});
```


# SMS Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/sms



```tsx theme={null}
await step.sms('send-sms', async () => {
  return {
    body: 'A new post has been created',
  };
});
```


# How to send PUSH notifications to iOS devices with FCM using Novu
Source: https://v0.x-docs.novu.co/guides/FCM-iOS-Novu/how-to-send-PUSH-notifications-to-iOS-devices-with-FCM-using-Novu

Learn how to integrate Firebase Cloud Messaging with Novu and send notifications to iOS

## Prerequisites

To complete this tutorial, you will need the following:

* [Apple Developer](https://developer.apple.com/) membership (to obtain the required permissions to send push notifications)
* A machine running MacOS to work on an iOS project
* [Firebase](https://firebase.google.com/) account
* [Novu](https://web.novu.co/?utm_campaign=docs-gs-guides-fcm-ios) account
* [Xcode](https://developer.apple.com/xcode/) installed on your machine

## Create an iOS app

Open Xcode and create a new project, choosing the **App** template.

Give your project a name, and select your name as the team for now, or leave it blank.

Your bundle identifier will be generated here — you will use this later when connecting to Firebase.

Select **SwiftUI** as your interface and **Swift** as your language.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Let's build and run our iOS application to see if everything works correctly.

<Frame>
  <img />
</Frame>

Go to the Firebase documentation website, go to docs here, and select Cloud Messaging.
We will follow this guide to set up cloud messaging inside the app.

You can read more about how Firebase Cloud Messaging works by reading their [official documentation](https://firebase.google.com/docs/cloud-messaging/ios/client).

<Frame>
  <img />
</Frame>

Go to iOS+ and click on the `Set up an Apple platforms client` section.

<Frame>
  <img />
</Frame>

The first thing that we need to do is add Firebase to our iOS app.
Let's create a new Firebase project inside of the console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Create a Firebase project

Select a name for your project.

<Frame>
  <img />
</Frame>

Then, add Google Analytics to the Firebase project.

<Frame>
  <img />
</Frame>

Here, you can select your Google account.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We will click on Add Firebase to your iOS app.

<Frame>
  <img />
</Frame>

We first need to add the bundle name, so go to your iOS Xcode project and copy and paste the bundle name.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Download the `.plist` file and put it in the root of your project.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

You can put it right under `info.plist` file.

<Frame>
  <img />
</Frame>

We need to add the Firebase SDK using the Swift package manager.
Copy this [https://github.com/firebase/firebase-ios-sdk](https://github.com/firebase/firebase-ios-sdk) URL and then go to 'File`->`Add Package Dependencies...\`.
Paste that URL in the top right.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We must add the initialization code to the `AppDelegates.swift` file.

Let's import the "FirebaseCore" dependency by adding `import FirebaseCore` to the beginning of the file.

Then, we will copy `firebaseapp.configure()` and place it in `didFinishLaunchingWithOptions` method.

<Frame>
  <img />
</Frame>

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore //Here

@main
class AppDelegate: UIResponder, UIApplicationDelegate {



    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure() //Here
				FirebaseConfiguration.shared.setLoggerLevel(.min)
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

```

Click 'Next' and continue to the console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Let's build and run our project and see if we get Firebase log messages in the console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Create and upload our APNs authentication key

We will create and upload our APNs authentication key to the Firebase project settings.

<Frame>
  <img />
</Frame>

Navigate to [Apple Developer Member Center](https://developer.apple.com/account).

Head to the "Keys" section under "Certificates, IDs & Profiles".

<Frame>
  <img />
</Frame>

Create a new key.

<Frame>
  <img />
</Frame>

Select "Apple Push Notification Service".

<Frame>
  <img />
</Frame>

Click "Register".

<Frame>
  <img />
</Frame>

We have to download this key and upload it into Firebase.

<Frame>
  <img />
</Frame>

Head to "Project Settings".

<Frame>
  <img />
</Frame>

Click on Cloud Messaging, then click "Upload APNs Authentication Key".

<Frame>
  <img />
</Frame>

Now we can upload the dots p8 file.

<Frame>
  <img />
</Frame>

You must enter your `Key ID` and `Team ID`, which you can find in the top right corner.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Register for Remote Notifications

<Frame>
  <img />
</Frame>

1. Copy this code block and place it inside the `AppDelegate.swift` file using the `didFinishLaunchingWithOptions` method.
   We paste this code block under `firebaseApp.configure()`.

2. We need to conform to this delegate, so we will also create an `AppDelegate` extension at the bottom for `UNUserNotificationCenterDelegate`.

3. Add `import FirebaseMessaging` to the file.

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {



    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
}

```

## Access the Registration Token

To do this, we must first set the `Messaging.messaging().delegate = self` inside the `didFinishLaunchingWithOptions` method.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We will now add a 'Messaging' delegate extension to `AppDelegate.swift` file.

<Frame>
  <img />
</Frame>

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce on 13/01/2024.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {



    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        FirebaseConfiguration.shared.setLoggerLevel(.min)

        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()
        
        // Messaging Delegate
        
        Messaging.messaging().delegate = self

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
      // Receive displayed notifications for iOS 10 devices.
      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  willPresent notification: UNNotification) async
        -> UNNotificationPresentationOptions {
        let userInfo = notification.request.content.userInfo

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // ...

        // Print full message.
        print(userInfo)

        // Change this to your preferred presentation option
        return [[.alert, .sound]]
      }

      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  didReceive response: UNNotificationResponse) async {
        let userInfo = response.notification.request.content.userInfo

        // ...

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // Print full message.
        print(userInfo)
      }
    }
    


extension AppDelegate: MessagingDelegate {
  
  func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
    print("Firebase registration token: \(String(describing: fcmToken))")
    
    let dataDict: [String: String] = ["token": fcmToken ?? ""]
    NotificationCenter.default.post(
      name: Notification.Name("FCMToken"),
      object: nil,
      userInfo: dataDict
    )
    // TODO: If necessary send token to application server.
    // Note: This callback is fired at each app startup and whenever a new token is generated.
  }
  
  
}

```

## Receive messages in an Apple App

1. Copy this code block and place it in `UNUserNotificationCenterDelegate` extension.
2. Add the `didReceiveRemoteNotification`.
3. We must declare a `gcmMessageIDKey` inside of `AppDelegate`. We can define this as a `string` variable.

<Frame>
  <img />
</Frame>

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    let gcmMessageIDKey = "gcm.Message_ID"

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        FirebaseConfiguration.shared.setLoggerLevel(.min)

        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()
        
        // Messaging Delegate
        
        Messaging.messaging().delegate = self

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
      // Receive displayed notifications for iOS 10 devices.
      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  willPresent notification: UNNotification) async
        -> UNNotificationPresentationOptions {
        let userInfo = notification.request.content.userInfo

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // ...

        // Print full message.
        print(userInfo)

        // Change this to your preferred presentation option
        return [[.alert, .sound]]
      }

      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  didReceive response: UNNotificationResponse) async {
        let userInfo = response.notification.request.content.userInfo

        // ...

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // Print full message.
        print(userInfo)
      }
    
    func application(_ application: UIApplication,
                     didReceiveRemoteNotification userInfo: [AnyHashable: Any]) async
      -> UIBackgroundFetchResult {
      // If you are receiving a notification message while your app is in the background,
      // this callback will not be fired till the user taps on the notification launching the application.
      // TODO: Handle data of notification

      // With swizzling disabled you must let Messaging know about the message, for Analytics
      // Messaging.messaging().appDidReceiveMessage(userInfo)

      // Print message ID.
      if let messageID = userInfo[gcmMessageIDKey] {
        print("Message ID: \(messageID)")
      }

      // Print full message.
      print(userInfo)

      return UIBackgroundFetchResult.newData
    }

    
    }
    


extension AppDelegate: MessagingDelegate {
  
  func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
    print("Firebase registration token: \(String(describing: fcmToken))")
    
    let dataDict: [String: String] = ["token": fcmToken ?? ""]
    NotificationCenter.default.post(
      name: Notification.Name("FCMToken"),
      object: nil,
      userInfo: dataDict
    )
    // TODO: If necessary send token to application server.
    // Note: This callback is fired at each app startup and whenever a new token is generated.
  }
  
  
}

```

## Adding app capabilities

<Frame>
  <img />
</Frame>

Click on the plus sign (+) and select `Background Modes`.

<Frame>
  <img />
</Frame>

**Select the following options:**

* Background Fetch
* Remote Notifications
* Background Processing

<Frame>
  <img />
</Frame>

Add `Push Notifications` capabilities.

<Frame>
  <img />
</Frame>

## App Build

<Frame>
  <img />
</Frame>

It will ask if you want to receive notifications, and we will allow it.

<Frame>
  <img />
</Frame>

## Cloud Message Test

In your Firebase project, navigate to 'engage' section and click on 'messaging'.

<Frame>
  <img />
</Frame>

Click on "Send your first message".

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We're going to enter the `notification title` and the `notification text`, then we're going to send the test message.

<Frame>
  <img />
</Frame>

We must copy and paste this FCM registration token to confirm our device (A physical or a simulator). You can find it in your Xcode console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Click on 'Test'.

<Frame>
  <img />
</Frame>

You should see the notification on your device!

<Frame>
  <img />
</Frame>

## Novu account creation

<Frame>
  <img />
</Frame>

You can immediately configure FCM as a Push channel provider or navigate to the Integration Store.

<Frame>
  <img />
</Frame>

## Connecting FCM as a provider

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

You only need to configure FCM with Novu with the Firebase Service Accounts private key.

To acquire the account key JSON file for your service account, follow this instructions:

1. Select your project. Click the gear icon on the top of the sidebar.
2. Head to project settings.
3. Navigate to the service account tab.
4. Click "Generate New Private Key", then confirm by clicking "Generate Key".
5. Clicking Generate Key will download the JSON file.
6. Once the file is on your machine, paste the entire JSON file content in the Service Account field of the FCM provider in the integration store on Novu’s web dashboard.

Make sure your service account key JSON content contains these fields:

```JSON theme={null}

{
  "type": "service_account",
  "project_id": "PROJECT_ID",
  "private_key_id": "PRIVATE_KEY_ID",
  "private_key": "PRIVATE_KEY",
  "client_email": "FIREBASE_ADMIN_SDK_EMAIL",
  "client_id": "CLIENT_ID",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "CLIENT_X509_CERT_URL"
}

```

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Creating a workflow

In Novu, creating a workflow means establishing a blueprint for sending notifications within your app. This unified structure ties together email, in-app messages, SMS, push notifications, and chat into **one entity**.

Each workflow has a unique name and identifier and includes customized content for various channels, using `{{handlebars}}` variables for personalization.

This ensures consistent platform notifications and allows dynamic adjustments for individual subscribers, scenarios, and use cases.

Workflow creation is for streamlining automated notifications, enabling teams to communicate effectively without extensive technical expertise.

<Steps>
  <Step title="Nabigate to 'Workflows' tab and click on 'Blank Workflow'">
    <Frame>
      <img />
    </Frame>

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Add (Drag & Drop) the Push channel node to the workflow">
    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Click on the node, and start to modify the content. Once you are done, click on 'Update'">
    <Frame>
      <img />
    </Frame>
  </Step>
</Steps>

## Creating a subscriber

Creating a subscriber in Novu refers to the process of establishing a subscriber entity within the Novu platform. A subscriber is essentially the recipient of the notifications sent through Novu's system. When you create a subscriber, you're setting up the necessary information for Novu to send targeted notifications to that individual.

<Frame>
  <img />
</Frame>

<Steps>
  <Step title="Creating a subscriber">
    ```JSON theme={null}

    curl --location 'https://api.novu.co/v1/subscribers' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <YOUR_API_KEY>' \
    --data-raw '{
    "subscriberId": "12345678",
    "firstName": "Pawan",
    "lastName": "Jain",
    "email": "pawan.jain@domain.com",
    "phone": "+1234567890",
    "avatar": "avatar-url",
    "locale": "en-US",
    "data": {
      "isDeveloper": true,
      "customKey": "customValue"
      }
    }'

    ```

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Locating subscriber's FCM registration token">
    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Adding the registration token to the subscriber">
    <Note> Subscriber can have multiple device tokens </Note>

    Here, you can locate the Provider\_Identifier.

    <Frame>
      <img />
    </Frame>

    ```JSON theme={null}

        curl --request PUT \
      --url https://api.novu.co/v1/subscribers/{subscriber_id}/credentials \
    --header 'Content-Type: application/json' \
      --header 'Authorization: ApiKey <YOUR_API_KEY>' \
      --data '{
      "credentials":{
        "deviceTokens": ["token1", "token2"]
    },
      "integrationIdentifier":"<Provider_Identifier>",
      "providerId":"fcm"
    }'

    ```
  </Step>
</Steps>

## Sending a notification to iOS device with Novu

To send a notification with Novu, you are actually triggering a notification workflow.
You have the ability to test the trigger using the user interface or by calling Novu's API.

**Trigger a workflow via the API**

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "<REPLACE_WITH_DATA>"
         },
         "payload": {}
       }'

```

<Frame>
  <img />
</Frame>

## Dynamic Content

When we were creating the first workflow, we "Hardcoded" the content of the notification.

Now, we will determine the content when calling the API.

1. In the workflow, we should change the values of the `title` and the `body` to `{{title}}` and `{{body}}`.
   That way, we could insert values through the payload of the API call.

<Frame>
  <img />
</Frame>

2. Add a 'payload' object to the API call.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "This title was set via the Payload",
           "body": "Payload notification body"
         },
       }'

```

<Frame>
  <img />
</Frame>

## Sound of a notification

The name of a sound file in your app's main bundle or in the Library/Sounds folder of your app's container directory.
Specify the string "default" to play the system sound.

Use this key for regular notifications. For critical alerts, use the sound dictionary instead.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "Notification With Sound",
           "body": "Hello World from Novu"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "payload": {
                 "aps": {
                   "sound": "default" // configure sound to the notification
                 }
               }
             }
           }
         }
       }'

```

## Priority for notification

If you omit this header, APNs set the notification priority to `10`.

Specify `10` to send the notification immediately.

Specify `5` to send the notification based on power considerations on the user’s device.

Specify `1` to prioritize the device’s power considerations over all other factors for delivery and prevent awakening the device.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "apns-priority: 5",
           "body": "Novu's API"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "headers": {
				 "apns-priority":"5" //priority for notifications
			   },
               "payload": {
                 "aps": {}
               },
               "fcm_options": {}
             }
           }
         }
       }'

```

## Sending images

Up to this point, your notifications have all contained only text. But if you’ve received many notifications, you know that notifications can have rich content, such as images. It’d be great if your notifications showed users a nice image related to their content. Once again, Firebase makes this super simple.

To show an image in push notifications, you’ll need to create a ***Notification Service Extension***. This is a separate target in your app that runs in the background when your user receives a push notification. The service extension can receive a notification and change its contents before iOS shows the notification to the user.
You’ll use Firebase to send an image URL inside a notification.
You’ll then use a content extension to download the image and add it to the notification’s content.

In Xcode, go to File ▸ New ▸ Target…. Search for Notification Service Extension and select Next. Set a name and configure it to add to your main project.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Select **Finish**, and when prompted, select **Activate**.

<Frame>
  <img />
</Frame>

When you added the Firebase package to your project, it was only added to the your "main" (In my case it's "PushNotificationDemo") target, so now you need to add the necessary dependency to your new extension.
Open your app’s project settings and select the name you picked for the extention under Targets.

Under Frameworks and Libraries, select the + button, and search for FirebaseMessaging. Then, select Add. Your project should reflect the image below:

<Frame>
  <img />
</Frame>

Select the + button, and search for FirebaseMessaging. Then, select Add.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Now, open `NotificationService.swift`. This file is where you can customize notifications before the user sees them.

First, add the following import to the top of the file:
`import FirebaseMessaging`

Next, replace the contents of `didReceive(_:withContentHandler:)` with the following:

```Swift theme={null}

self.contentHandler = contentHandler
bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)
        
if let bestAttemptContent = bestAttemptContent {
// Modify the notification content here...
bestAttemptContent.title = "\(bestAttemptContent.title)"
            
// Call FIRMessaging extension helper API.

if let messagingContentHandler = self.contentHandler {
Messaging.serviceExtension().populateNotificationContent(bestAttemptContent, withContentHandler: messagingContentHandler)
 }
}

```

Typically, you’d have to search the field containing the image URL, download the image, and finish the presentation with the picture as an attachment.
Here, you’re using Firebase’s `FIRMessagingExtensionHelper` to perform all that work automatically in a straightforward helper method call.

Remember, iOS only allows you to download your attached image. If the extension’s code takes too long to run, the system will call `serviceExtensionTimeWillExpire()`.
This gives you a chance to gracefully finish up anything you are doing in the extension or to simply present the notification as is, which is the default implementation.

This is the entire `NotificationService.swift` file.

```Swift theme={null}

//
//  NotificationService.swift
//  Rich Notifications
//
//  Created by Emillien Pearce.
//

import UserNotifications
import FirebaseMessaging

class NotificationService: UNNotificationServiceExtension {

    var contentHandler: ((UNNotificationContent) -> Void)?
    var bestAttemptContent: UNMutableNotificationContent?

    override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
        
        self.contentHandler = contentHandler
        bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)
        
        if let bestAttemptContent = bestAttemptContent {
            // Modify the notification content here...
            bestAttemptContent.title = "\(bestAttemptContent.title)"
            
            // Call FIRMessaging extension helper API.
            if let messagingContentHandler = self.contentHandler {
                Messaging.serviceExtension().populateNotificationContent(bestAttemptContent, withContentHandler: messagingContentHandler)
            }
        }
    }
    
    override func serviceExtensionTimeWillExpire() {
        // Called just before the extension will be terminated by the system.
        // Use this as an opportunity to deliver your "best attempt" at modified content, otherwise the original push payload will be used.
        if let contentHandler = contentHandler, let bestAttemptContent =  bestAttemptContent {
            contentHandler(bestAttemptContent)
        }
    }

}

```

Let's **rebuild** our app again!

<Frame>
  <img />
</Frame>

When making the API call, we should include:

* "mutable-content": 1 inside the "aps" object.
* "image" in "fcm\_options" object,
* URL address of the image.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "This is a notification with an image",
           "body": "Check this out"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "headers": {},
               "payload": {
        "aps": {
          "mutable-content": 1
                 }
               },
      "fcm_options": {
        "image": "https://www.planetware.com/wpimages/2020/02/france-in-pictures-beautiful-places-to-photograph-eiffel-tower.jpg"
               }
             }
           }
         }
       }'

```

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Sending actionable notifications

1. Define Notification Actions:

In your `AppDelegate.swift` file, you should define the notification actions you want to add.
You can do this by creating a `UNNotificationAction` for each action you want to include.
For example, let's add two actions: "Accept" and "Reject".

```Swift theme={null}

// Add these lines inside your AppDelegate class, preferably below the existing extensions.

extension UNNotificationAction {
    static let accept = UNNotificationAction(
        identifier: "ACCEPT_ACTION",
        title: "Accept",
        options: [.foreground]
    )
    
    static let reject = UNNotificationAction(
        identifier: "REJECT_ACTION",
        title: "Reject",
        options: [.destructive, .foreground]
    )
}

```

2. Register Notification Category:

   You need to register the notification category with the actions you defined in your `didFinishLaunchingWithOptions` method:

   ```
   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
   // ... (your existing code)

   // Register notification category
   let acceptAction = UNNotificationAction.accept
   let rejectAction = UNNotificationAction.reject

   let messageCategory = UNNotificationCategory(
       identifier: "MESSAGE_CATEGORY",
       actions: [acceptAction, rejectAction],
       intentIdentifiers: [],
       options: []
   )

   UNUserNotificationCenter.current().setNotificationCategories([messageCategory])

   return true
   ```

}

````

3. Handle Action Taps:

Now, you need to handle the action taps in the `userNotificationCenter(_:didReceive response:)` method of your `AppDelegate`. 
You can check which action was tapped by inspecting the `response.actionIdentifier` property:

```Swift

func userNotificationCenter(_ center: UNUserNotificationCenter,
                            didReceive response: UNNotificationResponse) async {
    let userInfo = response.notification.request.content.userInfo

    if response.actionIdentifier == UNNotificationAction.accept.identifier {
        // Handle the "Accept" action
        print("User tapped Accept")
        // Perform the desired action for "Accept"
    } else if response.actionIdentifier == UNNotificationAction.reject.identifier {
        // Handle the "Reject" action
        print("User tapped Reject")
        // Perform the desired action for "Reject"
    } else {
        // Handle other actions or default behavior
        print("User tapped an action with identifier: \(response.actionIdentifier)")
    }
}

````

Your full `AppDelegate.swift` file should look like this:

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    let gcmMessageIDKey = "gcm.Message_ID"

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        FirebaseConfiguration.shared.setLoggerLevel(.min)

        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()
        
        // Register notification category
        let acceptAction = UNNotificationAction.accept
        let rejectAction = UNNotificationAction.reject
        
        let messageCategory = UNNotificationCategory(
            identifier: "MESSAGE_CATEGORY",
            actions: [acceptAction, rejectAction],
            intentIdentifiers: [],
            options: []
        )
        
        UNUserNotificationCenter.current().setNotificationCategories([messageCategory])
        
        // Messaging Delegate
        
        Messaging.messaging().delegate = self

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
      // Receive displayed notifications for iOS 10 devices.
      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  willPresent notification: UNNotification) async
        -> UNNotificationPresentationOptions {
        let userInfo = notification.request.content.userInfo

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // ...

        // Print full message.
        print(userInfo)

        // Change this to your preferred presentation option
        return [[.alert, .sound]]
      }

      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  didReceive response: UNNotificationResponse) async {
        let userInfo = response.notification.request.content.userInfo
          
          if response.actionIdentifier == UNNotificationAction.accept.identifier {
               // Handle the "Accept" action
               print("User tapped Accept")
               // Perform the desired action for "Accept"
           } else if response.actionIdentifier == UNNotificationAction.reject.identifier {
               // Handle the "Reject" action
               print("User tapped Reject")
               // Perform the desired action for "Reject"
           } else {
               // Handle other actions or default behavior
               print("User tapped an action with identifier: \(response.actionIdentifier)")
           }

        // ...

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // Print full message.
        print(userInfo)
          
          
      }
    
    func application(_ application: UIApplication,
                     didReceiveRemoteNotification userInfo: [AnyHashable: Any]) async
      -> UIBackgroundFetchResult {
      // If you are receiving a notification message while your app is in the background,
      // this callback will not be fired till the user taps on the notification launching the application.
      // TODO: Handle data of notification

      // With swizzling disabled you must let Messaging know about the message, for Analytics
      // Messaging.messaging().appDidReceiveMessage(userInfo)

      // Print message ID.
      if let messageID = userInfo[gcmMessageIDKey] {
        print("Message ID: \(messageID)")
      }

      // Print full message.
      print(userInfo)
          
          

      return UIBackgroundFetchResult.newData
    }

    
    }
    


extension AppDelegate: MessagingDelegate {
  
  func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
    print("Firebase registration token: \(String(describing: fcmToken))")
    
    let dataDict: [String: String] = ["token": fcmToken ?? ""]
    NotificationCenter.default.post(
      name: Notification.Name("FCMToken"),
      object: nil,
      userInfo: dataDict
    )
    // TODO: If necessary send token to application server.
    // Note: This callback is fired at each app startup and whenever a new token is generated.
  }
  
  
}

extension UNNotificationAction {
    static let accept = UNNotificationAction(
        identifier: "ACCEPT_ACTION",
        title: "Accept",
        options: [.foreground]
    )
    
    static let reject = UNNotificationAction(
        identifier: "REJECT_ACTION",
        title: "Reject",
        options: [.destructive, .foreground]
    )
}

```

Now, let’s trigger a notification with actionable buttons:

```JSON theme={null}

curl --location --request POST "https://api.novu.co/v1/events/trigger" \
     --header "Authorization: ApiKey 4de014990cfb201033014548be2db904" \
     --header "Content-Type: application/json" \
     --data-raw '{
    "name": "untitled",
    "to": {
        "subscriberId": "12345678"
    },
    "payload": {
        "title": "New Mission",
        "body": "Your mission, should you choose to accept it,"
    },
    "overrides": {
        "fcm": {
            "apns": {
                "payload": {
                    "aps": {
                        "category": "MESSAGE_CATEGORY"
                    }
                }
            }
        }
    }
}'

```

<Frame>
  <img />
</Frame>

## Additional resources

* [Generating a remote notification by Apple](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/generating_a_remote_notification)
* [Sending notification requests to APNs](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/sending_notification_requests_to_apns)


# How to Add Digest to Email Notifications
Source: https://v0.x-docs.novu.co/guides/add-digest-to-email-notifications

Leverage the digest functionality to send email notifications

# Introduction

In this guide, you’ll learn how to add digest functionality to email notifications. But before exploring the actual code, let’s understand what a digest notification is and how it works.

You can find the entire code(frontend as well as backend) for this app [here](https://github.com/novuhq/digest-email-app).

<Note>
  If, instead, you want to add digest to in-app notifications, we have a guide for that as well. Take a look [here](/guides/add-digest-to-inapp-notifications).
</Note>

### What is a Digest Notification?

Often when you associate notifications with user activity, the end user can be bombarded with messages because of the nature of the activity. Take for example the case of commenting in the context of a social media app. If you were to send a notification to a user for every comment they receive, and they happen to receive 100 comments, it could lead to user fatigue since you would have to send 100 messages.

This is where digest notifications come into the picture!

A digest notification is a notification that consolidates information from several notifications into one and delivers that notification to the end user instead of several separate messages.

### How does Digest Notification Work?

Novu has a built-in digest engine that collects multiple trigger events, aggregates them into a single message, and delivers it to the subscriber. You can use the digest engine by adding a ‘digest node’ to your workflow in the workflow editor in the [Novu dashboard](https://web.novu.co/workflows?utm_campaign=docs-digests). If you want to learn more about it, [this](/getting-started/concepts#digest) is a great place to start.

Let’s see it in action now!

# Add Digest Notification To An App

To get started with this, you need the following:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-digests) if you don’t have one yet.
* A working React development environment.

# Workflow setup in Novu

Once, you have these, follow the steps below:

1. Head over to the Novu Dashboard.
2. Click `Workflows` on the left sidebar of your Novu dashboard.
3. Click the `Create Workflow` button on the top right:

<Frame>
  <img />
</Frame>

Once you click the `create workflow` button, you’ll see a dropdown. Select `blank workflow` from the dropdown:

<Frame>
  <img />
</Frame>

You’ll now be taken to the workflow editor:

<Frame>
  <img />
</Frame>

Once here, you can add the channels you want to use for sending notifications and configure them. For this guide, we’ll use the `Email` channel. You’ll also see the `Digest` action on the right sidebar.

<Note>
  Each node that is added below the digest node will only be triggered after the specified time interval
</Note>

For example, in our case, say we want the email notification to be sent after every 6 hours. So, add the `digest` action below the `trigger node`, and add the `email` channel node below the `digest` node as shown below:

<Frame>
  <img />
</Frame>

The `digest` node allows you to set a specific time interval for when notifications should be sent:

<Frame>
  <img />
</Frame>

Once, you’ve configured it. Go ahead and configure the `email` channel as per your need:

<Frame>
  <img />
</Frame>

Here’s a brief explanation of all the options:

* **1-Preview:** This shows you a glimpse of what the email notification item will look like when delivered to the client.
* **2-Sender Name:** Lets you set the sender name for emails that the client will receive.
* **3-Subject:** This lets you define the subject line for the emails that the client will receive.
* **4-Filter:** This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.
* **5-Custom Code** - In custom code, you can write custom digest templates to show some/all parts of a message.
* **6-Test** - This allows you to send a test email to test if everything is working as per your wish.

You can write your own digest template in the 'custom code' section or just follow this guide as shown in the picture above. Once you’re done configuring this to your liking, click on the `update` button on the top right.

It’ll automatically create a trigger code that you can use in your app. To get it, click on the `get snippet` button on the top right and copy it:

<Frame>
  <img />
</Frame>

Now, let’s see how to add Novu to our app!

# Add Novu to the Backend and Configure it

In your backend, install the novu package using the following code:

```bash theme={null}
npm install @novu/node

```

Now, create a route that you want to hit when called from the front end. In our demo app, this is the route:

```jsx theme={null}
import express from 'express';

import { getEmailDigest } from '../controller/emaildigest.js';

const router = express.Router();

router.post('/sending-email-digest', getEmailDigest);

export default router;
```

Now, we need to write a controller function that will handle the logic for what is to be sent in the trigger function’s payload. In our case, this is the controller function:

```jsx theme={null}
import { sendEmailDigest } from '../novu/novu.js';

export const getEmailDigest = async (req, res) => {
  const { notif, email } = req.body;
  try {
    await sendEmailDigest(notif, email);
    res.status(201).json({ message: 'success', notif: notif });
  } catch (error) {
    res.status(409).json({ message: error.message });
  }
};
```

To make it modular, we’ll keep the trigger code in a separate function in a separate file (`novu.js`, in our case) and the trigger function is getting called in the controller function above by the name `getEmailDigest`.

If you’re following the guide, you’ve already copied the trigger function. But before we can add it to our app, we need one key thing - Subscribers.

Subscribers are users to which the notifications are sent. You can see a list of subscribers in the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-digests) as well.

In our app, we’ll create a subscriber in Node.js as we’re writing our backend in Node.js, but we also have backend [SDKs](/sdks/introduction) ([Node.js](https://github.com/novuhq/novu/tree/next/packages/node), [PHP](https://github.com/novuhq/novu-php), [.NET](https://github.com/novuhq/novu-dotnet), [Elixir](https://github.com/novuhq/novu-elixir), [Go](https://github.com/novuhq/go-novu), [Ruby](https://github.com/novuhq/novu-ruby), [Python](https://github.com/novuhq/novu-python), and [Kotlin](https://github.com/novuhq/novu-kotlin)) to choose from. The recommended way to create a subscriber in NodeJS is as follows:

```jsx theme={null}
await novu.subscribers.identify('digestEmailSub', {
  firstName: 'digest email subscriber',
  email: email,
});
```

Here, we’re creating a subscriber with the `subscriberID` of `digestEmailSub.` In most real-world scenarios, the `subscriberId` should be an alphanumeric entity like `adfa67y87ad0`. You can read more about subscribers [here](https://docs.novu.co/platform/subscribers/).

Back in our app, we can now add the trigger function:

```jsx theme={null}
import { Novu } from '@novu/node';

export const sendEmailDigest = async (notif, email) => {
  const novu = new Novu(process.env.YOUR_NOVU_API_KEY);
  await novu.subscribers.identify('digestEmailSub', {
    firstName: 'digest email subscriber',
    email: email,
  });

  novu.trigger('emaildigestworkflow', {
    to: {
      subscriberId: 'digestEmailSub',
      email: email,
    },
    payload: {
      notif: notif,
    },
  });
};
```

Now, we just need to hit the route defined above from the front end.

# Hit the backend route from the front end

From the front end, we just need to hit the route we had defined above. Below, I'm sharing the body component of the demo app I created to illustrate this:

```jsx theme={null}
const Body = () => {
  const [formInput, setFormInput] = useState({ notif: '', email: '' });
  const [buttonClicked, setButtonClicked] = useState(false);

  const onSubmitHandler = async (e) => {
    e.preventDefault();
    const response = await fetch(
      'https://emaildigestbackend.onrender.com/api/v1/sending-email-digest',
      {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(formInput),
      }
    );
    console.log(response.data);
    setFormInput({ notif: '' });
  };

  const handleClick = () => {
    setButtonClicked(true);

    // Reset the button feedback after a certain duration
    setTimeout(() => {
      setButtonClicked(false);
    }, 100);
  };

  const onChangeHandler = (e) => {
    const value = e.target.name === 'email' ? e.target.value.trim() : e.target.value;

    setFormInput((prev) => ({
      ...prev,
      [e.target.name]: value,
    }));
  };
  return (
    <div>
      <h1>Email Digest Playground</h1>
      <p>
        Don't know how to? Start{' '}
        <a className="underline" href="https://docs.novu.co/platform/digest/">
          {' '}
          here
        </a>
      </p>
      <form onSubmit={onSubmitHandler}>
        <div>
          <div>
            <label htmlFor="email" className="w-48">
              Email:
            </label>
            <input
              placeholder="Your Email here"
              value={formInput.email}
              id="email"
              name="email"
              onChange={onChangeHandler}
            />
          </div>
          <div>
            <label htmlFor="notif">Notification:</label>
            <textarea
              placeholder="Enter the notification text"
              value={formInput.notif}
              id="notif"
              name="notif"
              onChange={onChangeHandler}
            />
          </div>
        </div>

        <button onClick={handleClick} type="submit">
          <BiRightArrowAlt className="text-2xl" />
        </button>
      </form>
    </div>
  );
};
```

We're hitting the backend route we had created earlier. The backend has been deployed on render as can be seen in this code snippet above.

Congratulations on following the guide up until this point. We can style our app a little using [some TailwindCSS](https://github.com/novuhq/digest-email-app/blob/main/frontend/src/app.css).

If you’ve done everything as recommended, you’ll end up with an app that looks like this:

<Frame>
  <img />
</Frame>

In this app, when we enter the email id, some text in the input box, and click send, the notification appears in the inbox after the delay specified above (when we’re creating the workflow).

This is how we add digest to email notifications!


# How to Add Digest to In-App Notifications
Source: https://v0.x-docs.novu.co/guides/add-digest-to-inapp-notifications

Leverage the digest functionality to send in-app notifications

## Introduction

In this guide, you’ll learn how to add digest notifications to a React app. But before exploring the actual code, let’s understand what a digest notification is and how it works.

You can find the entire code(frontend as well as backend) for this app [here](https://github.com/novuhq/digest-learning-app/tree/main).

### What is a Digest Notification?

Often times when you associate notifications with user activity, the end user can be bombarded with messages because of the nature of the activity. Take for example the case of commenting in the context of a social media app. If you were to send a notification to a user for every comment they receive, and they happen to receive 100 comments, it could lead to user fatigue since you would have to send 100 messages.

This is where digest notifications come into the picture!

A digest notification is a notification that consolidates information from several notifications into one and delivers that notification to the end user instead of several separate messages.

### How does Digest Notification Work?

Novu has a built-in digest engine that collects multiple trigger events, aggregates them into a single message and delivers it to the subscriber. You can use the digest engine by adding a `digest node` to your workflow in the workflow editor in the [Novu dashboard](https://web.novu.co/workflows?utm_campaign=docs-digestsinapp).

Let’s see it in action now!

## Add Digest Notification To An App

To get started with this, you need the following:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-digestsinapp) if you don’t have one yet.
* A working React development environment.

## Workflow setup in Novu

Once, you have these, follow the steps below:

1. Head over to the Novu Dashboard.
2. Click `Workflows` on the left sidebar of your Novu dashboard.
3. Click the `Create Workflow` button on the top right:

<Frame>
  <img />
</Frame>

Once you click the `create workflow` button, you’ll see a dropdown. Select `blank workflow` from the dropdown:

<Frame>
  <img />
</Frame>

You’ll now be taken to the workflow editor:

<Frame>
  <img />
</Frame>

Once here, you can add the channels you want to use for sending notifications and configure them. For this guide, we’ll use the `In-App` channel. You’ll also see the `Digest` action on the right sidebar.

<Note>
  Each node that is added below the digest node will only be triggered after the specified time interval
</Note>

For example, in our case, say we want the In-App notification to be sent after every 6 hours. Next, add the `digest` action below the `trigger node`, and add the `in-app` channel node below the `digest` node as shown below:

<Frame>
  <img />
</Frame>

The `digest` node allows you to set a specific time interval for when notifications should be sent:

<Frame>
  <img />
</Frame>

Once, you’ve configured it. Go ahead and configure the `in-app` channel as per your need:

<Frame>
  <img />
</Frame>

Here’s a brief explanation of all the options:

* **1-Preview**: This shows you a glimpse of what each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.

In our case, we’re going to use the following:

<Frame>
  <img />
</Frame>

Once you’re done configuring this to your liking, click on the `update` button on the top right.
It’ll automatically create a trigger code that you can use in your app. To get it, click on the `get snippet` button on the top right and copy it:

<Frame>
  <img />
</Frame>

Now, let’s see how to add Novu to our app!

# Add Novu to the Backend and Configure it

In your backend, install the novu package using the following code:

```bash theme={null}
npm install @novu/node
```

Now, create a route which you want to hit when called from the front end. In our demo app, this is the route:

```jsx theme={null}
import express from 'express';
import { getDigest } from '../controller/digest.js';

const router = express.Router();

router.post('/sending-digest', getDigest);

export default router;
```

Now, we need to write a controller function that will handle the logic for what is to be sent in the trigger function’s payload. In our case, this is the controller function:

```jsx theme={null}
import { sendDigest } from '../novu/novu.js';

export const getDigest = async (req, res) => {
  const { name } = req.body;
  try {
    await sendDigest(name);
    res.status(201).json({ message: 'success', name: name });
  } catch (error) {
    res.status(409).json({ message: error.message });
  }
};
```

To make it modular, we’ll keep the trigger code in a separate function in a separate file (`novu.js`, in our case) and the trigger function is getting called in the controller function above by the name `getDigest`.

If you’re following the guide, you’ve already copied the trigger function. But before we can add it to our app, we need one key thing - **Subscribers.**

Subscribers are entities to which the notifications are sent. You can see a list of subscribers in the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-digests-inapp) as well.

In our app, we’ll create a subscriber in Node.js as we’re writing our backend in Node.js, but we also have backend [SDKs](/sdks/introduction) (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin) to choose from. The recommended way to create a subscriber in NodeJS is as follows:

```jsx theme={null}
await novu.subscribers.identify('aa234u787', {
  firstName: 'digest subscriber',
});
```

Here, we’re creating a subscriber with the `subscriberID` of `aa234u787.` You can read more about subscribers [here](/subscribers/subscribers).

Back in our app, we can now add the trigger function:

```jsx theme={null}
import { Novu } from '@novu/node';

export const sendDigest = async (name) => {
  const novu = new Novu(process.env.NOVU_API_KEY);

  await novu.subscribers.identify('aa234u787', {
    firstName: 'digest subscriber',
  });

  await novu.trigger('digest-showcase', {
    to: {
      subscriberId: 'aa234u787',
    },
    payload: {
      name: name,
    },
  });
};
```

Now, we just need to hit the route defined above from the front end and add Novu to it.

# Add Novu’s Notification Center to the front end

In the front end, install the Novu notification centre package using the following command:

```bash theme={null}
npm install @novu/notification-center

```

Now, import and render the component in your app. The code to do so is as follows:

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
  IMessage,
} from '@novu/notification-center';

function Header() {
  function onNotificationClick(message: IMessage) {
    // your logic to handle the notification click
    if (message?.cta?.data?.url) {
window.location.href = message.cta.data.url;
    }
  }

  return (
    <NovuProvider subscriberId={'USER_ID'} applicationIdentifier={'APP_ID_FROM_ADMIN_PANEL'}>
      <PopoverNotificationCenter onNotificationClick={onNotificationClick}>
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}

```

You can, of course, modify things as you need. For example, in our app, this is what we’ve done in the header:

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
} from '@novu/notification-center';
import '../css/Header.css';

const Header = () => {
  function onNotificationClick(message) {
    // your logic to handle the notification click
    if (message?.cta?.data?.url) {
window.location.href = message.cta.data.url;
    }
  }
  return (
    <div className="bell">
      <div className="intro">
        <h1 className="title">Play with the digest engine!</h1>
        <p className="desc">
          Don't know how to? Start <a href="https://docs.novu.co/platform/digest/">here</a>.
        </p>
      </div>
      <div className="center">
        <NovuProvider
          subscriberId={'aa234u787'}
          applicationIdentifier={process.env.REACT_APP_YOUR_APP_ID_FROM_ADMIN_PANEL}
        >
          <PopoverNotificationCenter onNotificationClick={onNotificationClick}>
            {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
          </PopoverNotificationCenter>
        </NovuProvider>
      </div>
    </div>
  );
};

export default Header;
```

You’ll also need to plug in your `applicationIdentifier`. You can get your `application id` from the settings menu in the Novu dashboard.

Beyond this, we just need to call the API we had written above when the form is submitted with the data we want in the payload. The code to do so is as follows:

```jsx theme={null}
import { useState } from 'react';
import axios from 'axios';
import '../css/Body.css';

const Body = () => {
  const [name, setName] = useState('');

  const onSubmitHandler = async (e) => {
    e.preventDefault();
    const res = await axios.post('http://localhost:3000/api/v1/sending-digest', { name });
    setName('');
  };
  const onChangeHandler = (e) => {
    setName(e.target.value);
  };
  return (
    <form onSubmit={onSubmitHandler} className="form">
      <label for="noti-text" className="label">
        Enter notification text:
      </label>
      <input
        id="noti-text"
        placeholder="Will be sent as a digest message"
        type="text"
        onChange={onChangeHandler}
        value={name}
        className="text"
      />
      <button className="btn" type="submit">
        {' '}
        Send{' '}
      </button>
    </form>
  );
};

export default Body;
```

The app is done now!

Congratulations for following the guide up until this point. We can style our app a little using [some CSS](https://github.com/novuhq/digest-learning-app/blob/main/frontend/src/App.css).

If you’ve done everything as recommended, you’ll end up with an app that looks like this:

<Frame>
  <img />
</Frame>

In this app, when we enter some text in the input box and click send, the notification appears in the bell icon after the delay specified above (when we’re creating the workflow).

This is how we add digest to in-app notifications!


# How to use Novu to send notifications to a channel in a Discord server
Source: https://v0.x-docs.novu.co/guides/discord-guide

Learn to send Discord notifications swiftly with Novu

# Introduction

In this guide, you'll learn how to use Novu to send notifications to any channel in a Discord server. But before coding anything up, we just need to go over a couple of setup steps.
The corresponding docs for this guide are available on our [docs](https://docs.novu.co/channels-and-providers/chat/discord).
<Note>The entire code for this app is available on our [GitHub](https://github.com/novuhq/discord-chat-app).</Note>

So let's begin!

# Set up Discord

Setting up Discord is fairly straightforward. You just need the `webhook Url`. It is pretty simple and can be done in the following easy steps:

1. Go to the channel you want to add the webhook to (you need to be an admin of the discord server).

<Frame>
  <img />
</Frame>

2. Right-click the channel and select “Edit Channel”.

<Frame>
  <img />
</Frame>

3. Select Integrations -> Webhooks -> Create Webhook

<Frame>
  <img />
</Frame>

4. Edit the Bot name to your liking, copy the webhook URL and store it somewhere. We'll need it in the future.

<Frame>
  <img />
</Frame>

# Set up Novu

In this part, we'll set up a workflow that will be triggered when we send a notification. Workflows are like blueprints and hold the entire flow of notifications. You can read more about them on our [docs](https://docs.novu.co/workflows/notification-workflows). To set up a notification workflow for our app, follow these steps:

1. Make sure that you've set the Discord Integration as active from the [Novu Integrations Store](https://web.novu.co/integrations?utm_campaign=docs-discordnotifications).

<Frame>
  <img />
</Frame>

2. Goto the [Novu Web Dashboard](https://web.novu.co/workflows?utm_campaign=docs-discordnotifications).
3. Click on the 'Add a workflow' button and select 'Blank workflow' from the dropdown.

<Frame>
  <img />
</Frame>

4. Once there, give your workflow a name and drag and drop the 'chat' option below the 'workflow trigger' step.

<Frame>
  <img />
</Frame>

5. You can also add variables in the Workflow Editor. For example, here I've added 'chatMsg' as a variable as I'll be sending data using it.

<Frame>
  <img />
</Frame>

<Info>Whatever is placed inside double braces is a variable.</Info>
6\. Click the 'Get Snippet' button, copy the trigger code and keep it somewhere. We'll need this to trigger this workflow.

<Frame>
  <img />
</Frame>

Now, we've completed all the setup required and can move to coding!

# Create the backend

The backend for this app is quite simple. Simply install the Novu package:

```bash theme={null}
npm install @novu/node

```

Now, create a route that you'll hit when called from the front end. For our demo app, this is the route I've created:

```jsx theme={null}
import express from "express";
import { chatController } from "../controller/chat.js";

const router = express.Router();

router.post("/sendChat",chatController);

export default router;
```

Now, we need a controller function to handle what is to be sent in the trigger's function payload. Here's the controller I wrote:

```jsx theme={null}
import { chat } from "../novu/novu.js"

export const chatController = async (req, res) => {
    const { chatMsg } = req.body;
    try {
        await chat(chatMsg);
        res.status(201).json({ message: "Message sent successfully" });
    } catch (error) {
        console.log("notifController error:", error);
        res.status(500).json({ message: error.message })
    }
}
```

<Info>Notice how we're expecting 'chatMsg' in our payload. This is why we added it as a variable in the workflow created earlier.</Info>
To make it modular, we’ll keep the trigger code in a separate function in a separate file, `novu.js`, in our case, which is as follows:

```jsx theme={null}
import { Novu, ChatProviderIdEnum } from '@novu/node';

export const chat = async (chatMsg) => {
    try {
        const novu = new Novu(process.env.YOUR_NOVU_API_KEY_HERE);

        await novu.subscribers.identify(process.env.SUB_ID, {
            firstName: 'newSubForDiscordChat',
        });

        await novu.subscribers.setCredentials(process.env.SUB_ID, ChatProviderIdEnum.Discord, {
            webhookUrl: process.env.WEBHOOK_URL
        });

    } catch (error) {
        console.log(error);
    }
}
```

Add the trigger code you'd copied earlier:

```jsx theme={null}
import { Novu } from '@novu/node'; 

const novu = new Novu('<API_KEY>');

novu.trigger('chat-with-discord', {
    to: {
      subscriberId: '<REPLACE_WITH_DATA>'
    },
    payload: {
      chatMsg: '<REPLACE_WITH_DATA>'
    }
  });
```

Our final trigger code should look something like this:

```jsx theme={null}
import { Novu, ChatProviderIdEnum } from '@novu/node';

export const chat = async (chatMsg) => {
    try {
        const novu = new Novu(process.env.YOUR_NOVU_API_KEY_HERE);

        await novu.subscribers.identify(process.env.SUB_ID, {
            firstName: 'newSubForDiscordChat',
        });

        await novu.subscribers.setCredentials(process.env.SUB_ID, ChatProviderIdEnum.Discord, {
            webhookUrl: process.env.WEBHOOK_URL
        });

        await novu.trigger('chat-with-discord', {
            to: {
                subscriberId: process.env.SUB_ID
            },
            payload: {
                chatMsg: chatMsg
            }
        });
    } catch (error) {
        console.log(error);
    }
}
```

<Info>We're keeping all the sensitive data in a `.env` file to avoid hardcoding as a good practice</Info>

In this code snippet above, we're first initializing a new instance of Novu, then using it to 'identify' or [create](https://docs.novu.co/subscribers/subscribers#create-a-subscriber) a [subscriber](https://docs.novu.co/subscribers/subscribers).
<Info>The 'identify' method tries to find a subscriber with the given info. If it can't find any such subscriber, it creates a new subscriber with the supplied info.</Info>
After creating the subscriber, it runs the trigger code for the workflow we had created.

# Front end set up

For our demonstration purposes, the front-end is pretty basic. All we have to do is have an input field to take the notification text in and send the payload. The front-end code for this demo app is available on our [Github repo](https://github.com/novuhq/discord-chat-app/tree/main/frontend).
And here's our app in all its glory!

<Frame>
  <img />
</Frame>

This is how we send Discord notifications using Novu!


# How to send push notifications to Flutter apps (Android & iOS) with FCM using Novu
Source: https://v0.x-docs.novu.co/guides/fcm-flutter-novu/how-to-send-push-notifications-to-flutter-apps-with-fcm-using-Novu

Learn how to integrate Firebase Cloud Messaging with Novu and send notifications to Flutter apps

## Prerequisites

To complete this guide, you will need the following:

* [Apple Developer](https://developer.apple.com/) membership (to obtain the required permissions to send push notifications).
* A machine running MacOS to work on building the Flutter app for iOS devices.
* [Firebase](https://firebase.google.com/) account
* [Novu](https://web.novu.co/?utm_campaign=docs-gs-guides-fcm-flutter) account.
* [Android Studio](https://developer.android.com/studio/install) configured with Dart and Flutter plugins.
* [Xcode](https://developer.apple.com/xcode/) installed on your machine.

Check out the [Flutter app code for this guide on GitHub](https://github.com/novuhq/flutter-fcm-novu).

## Set up and Create a Flutter App

If you have an existing Flutter App, you can skip this step.

If you are creating a brand new Flutter app, please follow this [guide](https://firebase.google.com/codelabs/firebase-fcm-flutter#0).

## Set up Firebase and FlutterFire

Please follow this [guide to set up a Firebase project and integrate Firebase Cloud Messaging in your Flutter app](https://firebase.google.com/codelabs/firebase-fcm-flutter#2).

## Set Up Apple Integration

Please follow this [guide to ensure that everything is set up on your iOS device](https://firebase.flutter.dev/docs/messaging/apple-integration) to receive messages.

There is an optional section about allowing **Notification Images**. Follow the steps to install and activate the notification service extension. We'll need it later in this guide to display images as part of the push notifications from FCM.

## Set Up FCM Notification Permission & Registration Token

We'll add code to initialize Firebase and ask the user's permission to receive notifications.

Open up the `lib/main.dart` file in your Flutter app and replace everything with the code below:

```dart theme={null}
import 'package:flutter/foundation.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:flutter/material.dart';
import 'firebase_options.dart';
import 'package:firebase_messaging/firebase_messaging.dart'; // FlutterFire's Firebase Cloud Messaging plugin

// Add Stream controller
import 'package:rxdart/rxdart.dart';

// for passing messages from event handler to the UI
final _messageStreamController = BehaviorSubject<RemoteMessage>();

@pragma('vm:entry-point')
Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
  // If you're going to use other Firebase services in the background, such as Firestore,
  // make sure you call `initializeApp` before using other Firebase services.
  await Firebase.initializeApp();

  print("Handling a background message: ${message.messageId}");
  print('Message data: ${message.data}');
  print('Message notification: ${message.notification?.title}');
  print('Message notification: ${message.notification?.body}');

}

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );

  // Request permission
  final messaging = FirebaseMessaging.instance;

  // Web/iOS app users need to grant permission to receive messages
  final settings = await messaging.requestPermission(
    alert: true,
    announcement: false,
    badge: true,
    carPlay: false,
    criticalAlert: false,
    provisional: false,
    sound: true,
  );

  if (kDebugMode) {
    print('Permission granted: ${settings.authorizationStatus}');
  }

  // Register with FCM
  // It requests a registration token for sending messages to users from your App server or other trusted server environment.
  String? token = await messaging.getToken();

  if (kDebugMode) {
    print('Registration Token=$token');
  }

  // Set up foreground message handler
  FirebaseMessaging.onMessage.listen((RemoteMessage message) {
    if (kDebugMode) {
      print('Handling a foreground message: ${message.messageId}');
      print('Message data: ${message.data}');
      print('Message notification: ${message.notification?.title}');
      print('Message notification: ${message.notification?.body}');
    }

    _messageStreamController.sink.add(message);
  });

  // Set up background message handler
  FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);

  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const MyHomePage(title: 'Flutter Demo Home Page'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({Key? key, required this.title}) : super(key: key);

  final String title;

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  String _lastMessage = "";

  _MyHomePageState() {
    _messageStreamController.listen((message) {
      setState(() {
        if (message.notification != null) {
          _lastMessage = 'Received a notification message:'
              '\nTitle=${message.notification?.title},'
              '\nBody=${message.notification?.body},'
              '\nData=${message.data}';
        } else {
          _lastMessage = 'Received a data message: ${message.data}';
        }
      });
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            Text('Last message from Firebase Messaging:',
                style: Theme.of(context).textTheme.titleLarge),
            Text(_lastMessage, style: Theme.of(context).textTheme.bodyLarge),
          ],
        ),
      ),
    );
  }
}
```

*lib/main.dart*

There are 4 sections to pay attention to:

<Steps>
  <Step title="The Request permission code block">
    This shows the notification permission prompt to the user when the user interacts with the app for the first time. If the user allows it, then we can get a token.

    ```dart theme={null}
    // Request permission
    final messaging = FirebaseMessaging.instance;

    // Web/iOS app users need to grant permission to receive messages
    final settings = await messaging.requestPermission(
      alert: true,
      announcement: false,
      badge: true,
      carPlay: false,
      criticalAlert: false,
      provisional: false,
      sound: true,
    );
    ```
  </Step>

  <Step title="Registering and obtaining the FCM token for the device">
    A device's token is needed for the specific device to receive messages. The `getToken()` returns the registration token for the app instance on the device.

    ```dart theme={null}
      String? token = await messaging.getToken();

      if (kDebugMode) {
        print('Registration Token=$token');
      }
    ```
  </Step>

  <Step title="The foreground message handler">
    This handler listens to when a push notification is sent from FCM to the device. If the app is in the foreground, then it prints out the notification title, body, messageId, and data properties to the console.

    ```dart theme={null}
      FirebaseMessaging.onMessage.listen((RemoteMessage message) {
        if (kDebugMode) {
          print('Handling a foreground message: ${message.messageId}');
          print('Message data: ${message.data}');
          print('Message notification: ${message.notification?.title}');
          print('Message notification: ${message.notification?.body}');
        }

        _messageStreamController.sink.add(message);
      });
    ```
  </Step>

  <Step title="The background message handler">
    This handler listens to when a push notification is sent from FCM to the device. If the app is in the background, then it prints out the notification title, body, messageId, and data properties to the console.

    ```dart theme={null}
      ...
      @pragma('vm:entry-point')
      Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
        // If you're going to use other Firebase services in the background, such as Firestore,
        // make sure you call `initializeApp` before using other Firebase services.
        await Firebase.initializeApp();

        print("Handling a background message: ${message.messageId}");
        print('Message data: ${message.data}');
        print('Message notification: ${message.notification?.title}');
        print('Message notification: ${message.notification?.body}');

      }
      ...


      FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);
    ```
  </Step>
</Steps>

Now, run the Flutter app. Your device should be connected to your machine to enable the app to run on it.

<Frame>
  <img />
</Frame>

<br />

<Frame>
  <img />
</Frame>

<br />

<Frame>
  <img />
</Frame>

## Cloud Message Test

In your Firebase project, navigate to `Engage` section and click on `Messaging`.

<Frame>
  <img />
</Frame>

Click on `Create your first campaign` and select `Firebase Notification messages`.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Enter the `Notification title` and the `Nabigateotification text`, and click on `Send test message`.

<Frame>
  <img />
</Frame>

We must copy and paste this FCM registration token to confirm our device. You can find it logged as shown earlier in our editor.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Click on 'Test'.

<Frame>
  <img />
</Frame>

You should see the notification on your device!

<Frame>
  <img />
</Frame>

## Sign Up on Novu

Let's use Novu to fire push notifications via FCM. First, sign up on [Novu Cloud](https://web.novu.co)?utm\_campaign=docs-gs-guides-fc-flutter.

<Frame>
  <img />
</Frame>

Next, immediately configure FCM as a Push channel provider.

<Frame>
  <img />
</Frame>

You can also do this by heading straight to the `Integrations Store`. Click on `Add a provider`.

## Connect  FCM as a Push Channel provider

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

You only need to configure FCM with Novu with the Firebase Service Accounts private key.

To acquire the account key JSON file for your service account, follow this instructions:

1. Select your project. Click the gear icon on the top of the sidebar.
2. Head to project settings.
3. Navigate to the `Service accounts` tab.
4. Click `Generate new private key`, then confirm by clicking `Generate key`.
5. Click `Generate key` to download the JSON file.
6. Once the file is on your machine, paste the entire JSON file content in the `Service Account` field of the FCM provider in the Integration store on Novu’s web dashboard.

Make sure your service account key JSON content contains these fields:

```JSON theme={null}

{
  "type": "service_account",
  "project_id": "PROJECT_ID",
  "private_key_id": "PRIVATE_KEY_ID",
  "private_key": "PRIVATE_KEY",
  "client_email": "FIREBASE_ADMIN_SDK_EMAIL",
  "client_id": "CLIENT_ID",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "CLIENT_X509_CERT_URL"
}

```

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Create a Notification Workflow

In Novu, creating a workflow means establishing a blueprint for sending notifications within your app. This unified structure ties together email, in-app messages, SMS, push notifications, and chat into **one entity**.

Each workflow has a unique name and identifier and includes customized content for various channels, using `{{handlebars}}` variables for personalization.

This ensures consistent platform notifications and allows dynamic adjustments for individual subscribers, scenarios, and use cases.

<Steps>
  <Step title="Navigate to 'Workflows' tab and click on 'Blank Workflow'">
    <Frame>
      <img />
    </Frame>

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Add (Drag & Drop) the Push channel node to the workflow">
    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Click on the node, and start to modify the content. Add a title and content. Once you are done, click on 'Update'">
    <Frame>
      <img />
    </Frame>
  </Step>
</Steps>

We need to fire notifications to subscribers. So, let's create a subscriber!

## Create A Subscriber & Update Credentials

A subscriber is essentially the recipient of the notifications sent through Novu's system. When you create a subscriber, you're setting up the necessary information for Novu to send targeted notifications to that individual.

You can see the list of subscribers in the `Subscribers` section of the Novu dashboard.

<Frame>
  <img />
</Frame>

<Steps>
  <Step title="Create a subscriber">
    ```JSON theme={null}

    curl --location 'https://api.novu.co/v1/subscribers' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <YOUR_API_KEY>' \
    --data-raw '{
    "subscriberId": "584349343",
    "firstName": "Flutter",
    "lastName": "Boy",
    "email": "flutterboy@gmail.com",
    }'

    ```

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Grab the FCM device token from your Editor log">
    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Add Device Tokens to Subscriber by Updating Subscriber Credentials">
    <Note> Subscriber can have multiple device tokens </Note>

    Here, you can locate the Provider\_Identifier.

    <Frame>
      <img />
    </Frame>

    ```JSON theme={null}

      curl --request PUT \
          --url https://api.novu.co/v1/subscribers/{subscriber_id}/credentials \
          --header 'Content-Type: application/json' \
          --header 'Authorization: ApiKey <YOUR_API_KEY>' \
          --data '{
              "credentials":{
                "deviceTokens": ["<insert-fcm-token>"]
            },
            "integrationIdentifier":"<Provider_Identifier>",
            "providerId":"fcm"
      }'

    ```

    *Update the Subscriber Credentials by adding the device tokens to the subscriber*
  </Step>
</Steps>

## Sending a Push Notification to a Device(Android/iOS) with Novu

To send a notification with Novu, you are actually triggering a notification workflow.
You have the ability to test the trigger using the Novu UI or by calling Novu's API.

**Trigger a workflow via the API**

Insert the `trigger identifier` as the name in the API request below:

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "<REPLACE_WITH_DATA>"
         },
         "payload": {}
       }'

```

**Trigger a workflow via the Novu Dashboard**

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

**Receive Triggered Push Workflow on Device**

<Frame>
  <img />
</Frame>

## Dynamic Content

When we were creating the first workflow, we "Hardcoded" the content of the notification.

Now, we will determine the content when calling the API.

1. In the workflow, we should change the values of the `title` and the `body` to `{{title}}` and `{{body}}`.
   That way, we could insert values through the payload of the API call.

<Frame>
  <img />
</Frame>

2. Add a `payload` object to the API call.

Insert the `trigger identifier` as the name in the API request below:

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "This title was set via the Payload",
           "body": "This body was set via the Payload"
         },
       }'

```

<Frame>
  <img />
</Frame>

## Handling Data Type Messages

With FCM, you can send `Notification` and `Data` messages. We have handled sending notification messages. Let's handle data messages.

Data messages contain user-defined custom key-value pairs. The information is encapsulated in the `data` key. The app can do whatever it pleases with the data once it's received by the device.

**Via the Trigger API call**

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "This title was set via the Payload",
           "body": "This body was set via the Payload"
         },
         "overrides": {
          "fcm": {
            "data": {
              "subscription_status": "active",
              "renewed_by": "bisola"
            }
          }
         }
       }'

```

<Frame>
  <img />
</Frame>

## Sound of a notification

You can use the name of a sound file in your app's main bundle or in the Library/Sounds folder of your app's container directory.

Specify the string "default" to play the system sound. Use it for regular notifications. For critical alerts, use the sound dictionary instead.

The code below works for iOS devices:

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "Notification With Sound",
           "body": "Hello World from Novu"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "payload": {
                 "aps": {
                   "sound": "default" // configure sound to the notification
                 }
               }
             }
           }
         }
       }'

```

For Android devices, use the following:

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "Notification With Sound",
           "body": "Hello World from Novu"
         },
         "overrides": {
           "fcm": {
             "android": {
               "notification": {
                 "defaultSound": true // This uses the Android framework's default sound for the notification.
               }
             }
           }
         }
       }'

```

## Priority for notification

If you omit this header, APNs (iOS) set the notification priority to `10`.

* Specify `10` to send the notification immediately.
* Specify `5` to send the notification based on power considerations on the user’s device.
* Specify `1` to prioritize the device’s power considerations over all other factors for delivery and prevent awakening the device.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "apns-priority: 5",
           "body": "Novu's API"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "headers": {
				          "apns-priority":"5" //priority for notifications
			          },
               "payload": {
                 "aps": {}
               },
               "fcm_options": {}
             }
           }
         }
       }'

```

For Android devices, specify `high` or `normal` for the priority of the notification message.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "priority",
           "body": "Novu's API"
         },
         "overrides": {
           "fcm": {
             "android": {
               "priority": "high"
             }
           }
         }
       }'

```

## Sending Push Notification With Image

Up to this point, your notifications have all contained only text. But if you’ve received many notifications, you know that notifications can have rich content, such as images. It’d be great if your notifications showed users a nice image related to their content. Once again, Firebase makes this super simple.

To show an image in push notifications, you’ll need to create a ***Notification Service Extension***. We handled it earlier in this guide during the Apple setup.

For reiteration, follow [this guide](https://firebase.flutter.dev/docs/messaging/apple-integration#advanced-optional-allowing-notification-images) to ensure it is properly set up for iOS devices.

When making the API call, we should include:

* "mutable-content": 1 inside the “aps” object.
* "image" in "fcm\_options" object,
* URL address of the image.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "This is a notification with an image",
           "body": "Check this out"
         },
         "overrides": {
           "fcm": {
             "apns": {
                "payload": {
                  "aps": {
                    "mutable-content": 1
                  }
                },
                "fcm_options": {
                  "image": "https://www.planetware.com/wpimages/2020/02/france-in-pictures-beautiful-places-to-photograph-eiffel-tower.jpg"
                  }
            }
          }
        }
    }'
```

## Additional resources

* [Notifications Usage - Flutter Fire](https://firebase.flutter.dev/docs/messaging/notifications)


# How to send notifications with Next.js and MJML
Source: https://v0.x-docs.novu.co/guides/framework-guides/framework-mjml

Leverage MJML package to send email notifications

# Introduction

This guide will walk you through how to send notifications with MJML and Novu. You can check out the code for a [sample demo app](https://github.com/novuhq/framework-mjml).

## Pre-requisites

* A Novu account
* Node installed on your machine
* A working NextJS development environment

## Get started with Novu Framework

[Novu Framework](https://docs.novu.co/framework/quickstart) is a "notifications as code" approach that enables developers to define workflows as functions and integrate them with their preferred libraries for email, SMS, and chat generation.

1. To get started with Novu Framework, just run this command in your terminal, it’ll scaffold a new NextJS project with Novu Framework and we’ll be ready to roll!

```jsx theme={null}
npx create-novu-app --api-key=<YOUR_API_KEY>

```

2. Once you execute this command, you’ll be asked to give your project a name. I’ll keep the default `my-novu-app` but you can choose your own.

<Frame>
  <img />
</Frame>

3. You’ll then be asked if you want to use React-email or not. Since, we’ll be using MJML, I’m choosing the default 'No' option.

<Frame>
  <img />
</Frame>

4. After this step, all the dependencies will be installed and you will be able to start using Novu Framework.

<Frame>
  <img />
</Frame>

5. Once this installation is complete, simply cd into the directory and start your app using the `npm run dev` command, and your app will be served on `localhost:4000`

<Note>
  Make sure that the port 4000 isn’t already being used!
</Note>

You’ll now have a NextJS app running on `http://localhost:4000` and you can make changes to your app as you see fit. Let’s now move to the meaty stuff - using Novu Framework in a NextJS app and the magic of Dev Studio.

## Echo Dev Studio

The Echo Dev Studio is a companion app to the Echo Client SDK. Its goal is to provide a local environment that lives near your code.

To launch the dev studio locally you can run: `npx novu-labs@latest echo`. The Dev Studio will be started by default on port `2022`, and accessible via: `http://localhost:2022`

<Frame>
  <img />
</Frame>

Here’s how the Dev Studio looks on the first run:

<Frame>
  <img />
</Frame>

You’ll notice that it asks for an `Echo endpoint` at the bottom. Novu Echo requires a single HTTP endpoint (`/api/echo` or similar) to be exposed by your application. This endpoint is used to receive events from our Worker Engine. We have more on Novu endpoint [in our docs.](https://docs.novu.co/framework/concepts/endpoint)

<Note>
  You can view the Echo Endpoint as a webhook endpoint that Novu will call when it needs to retrieve contextual information for a given subscriber and notification.
</Note>

Just enter the full URL of your Echo Endpoint. In our case, it is `http://localhost:4000/api/echo`

<Frame>
  <img />
</Frame>

Once you do, you’ll see a green checkmark alongside the URL input box and a green `connected` highlight at the top right corner.

## Installing and configuring MJML

Integrating MJML with Novu in our NextJS app is quite straightforward, with just one small caveat. Following are the steps to get it installed and configured:

1. Simply run the following command to install it like any other npm package:

```bash theme={null}
npm i mjml
```

<Warning>
  Once installed, you need to keep in mind that, MJML doesn’t play very nice with newer web technologies such as Next.js that we’re using today. In order to overcome some hurdles, we need to use the `require` statement when importing MJML in our files, such as when defining the template.
</Warning>

2. To write an email template, you can look over some of the examples in the MJML documentation to get inspiration from. In our case, this is the template:

```jsx theme={null}
// notice the use of require statement here:
const mjml2html = require("mjml")

export const mjmlTemplate = (inputs: Inputs) => {
    const { text, buttonText, imageUrl, buttonUrl } = inputs;
    return (mjml2html(`
    <mjml>
    <mj-body background-color="#d7dde5">
      <mj-section full-width="full-width">
        <mj-column width="66.66666666666666%" vertical-align="middle">
          <mj-text align="left" font-size="11px" padding-bottom="0px" padding-top="0"><span style="font-size: 11px">${text}</span></mj-text>
        </mj-column>
        <mj-column width="33.33333333333333%" vertical-align="middle">
          <mj-text align="right" font-size="11px" padding-bottom="0px" padding-top="0"><span style="font-size: 11px"><a href="${buttonUrl}" style="text-decoration: none; color: inherit;">OnePage</a></span></mj-text>
        </mj-column>
      </mj-section>
      <mj-section background-color="#ffffff" full-width="full-width">
        <mj-column width="33.33333333333333%" vertical-align="middle">
          <mj-image src="http://191n.mj.am/img/191n/1t/hx.png" alt="OnePage" padding-bottom="0px" padding-top="10px"></mj-image>
        </mj-column>
        <mj-column width="66.66666666666666%" vertical-align="middle">
          <mj-text align="center" padding-bottom="0px" padding-top="10px"><a href="${buttonUrl}" style="text-decoration: none; color: inherit;">Home</a>&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;<a href="${buttonUrl}" style="text-decoration: none; color: inherit;">Features</a>&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;
            <a href="${buttonUrl}" style="text-decoration: none; color: inherit;">Portfolio</a>
          </mj-text>
        </mj-column>
      </mj-section>
      <mj-section background-url="${imageUrl}" vertical-align="middle" background-size="cover" full-width="full-width" background-repeat="no-repeat">
        <mj-column width="100%" vertical-align="middle">
          <mj-text align="center" font-size="14px" color="#45474e" padding-bottom="10px" padding-top="45px"><span style="font-size: 30px; line-height: 30px;">More than an email template</span><br /><br />Only on <span style="color: #e85034">Mailjet</span> template builder</mj-text>
          <mj-button align="center" background-color="#e85034" color="#fff" border-radius="24px" href="${buttonUrl}" font-family="Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif" padding-bottom="45px" padding-top="10px">${buttonText}</mj-button>
        </mj-column>
      </mj-section>
      <mj-section background-color="#ffffff" vertical-align="top" full-width="full-width">
        <mj-column vertical-align="top" width="33.33333333333333%">
          <mj-image src="http://191n.mj.am/img/191n/1t/hs.png" alt="" width="50px"></mj-image>
          <mj-text align="center" color="#9da3a3" font-size="11px" padding-bottom="30px"><span style="font-size: 14px; color: #e85034">Best audience</span><br /><br />Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque eleifend sagittis nunc, et fermentum est ullamcorper dignissim.</mj-text>
        </mj-column>
        <mj-column vertical-align="top" width="33.33333333333333%">
          <mj-image src="http://191n.mj.am/img/191n/1t/hm.png" alt="" width="50px"></mj-image>
          <mj-text align="center" color="#9da3a3" font-size="11px" padding-bottom="30px"><span style="font-size: 14px; color: #e85034">Higher rates</span><br /><br />Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque eleifend sagittis nunc, et fermentum est ullamcorper dignissim.</mj-text>
        </mj-column>
        <mj-column vertical-align="top" width="33.33333333333333%">
          <mj-image src="http://191n.mj.am/img/191n/1t/hl.png" alt="" width="50px"></mj-image>
          <mj-text align="center" color="#9da3a3" font-size="11px" padding-bottom="30px" padding-top="3px"><span style="font-size: 14px; color: #e85034">24/7 Support</span><br /><br />Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque eleifend sagittis nunc, et fermentum est ullamcorper dignissim.</mj-text>
        </mj-column>
      </mj-section>
      <mj-section background-color="#e85034" vertical-align="middle" full-width="full-width">
        <mj-column width="100%" vertical-align="middle">
          <mj-text align="center" color="#ffffff" font-size="18px" padding-bottom="10px">Why choose us?</mj-text>
          <mj-divider border-color="#fff" border-style="solid" border-width="1px" padding-left="100px" padding-right="100px" padding-bottom="20px" padding-top="20px"></mj-divider>
          <mj-text align="center" color="#f8d5d1" font-size="11px" padding-bottom="25px">Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris. Lorem ipsum dolor sit amet, consectetur adipiscing
            elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris.</mj-text>
        </mj-column>
      </mj-section>
      <mj-section vertical-align="middle" background-color="#ffffff" full-width="full-width">
        <mj-column width="50%" vertical-align="middle">
          <mj-image src="http://191n.mj.am/img/191n/1t/h2.jpg" alt="" padding-bottom="20px" padding-top="20px"></mj-image>
        </mj-column>
        <mj-column width="50%" vertical-align="middle">
          <mj-text align="left" color="#9da3a3" font-size="11px" padding-bottom="25px" padding-top="25px"><span style="font-weight: bold; font-size: 14px; color: #45474e">Great newsletter for the best company out there</span><br /><br />Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna
            aliqua. Ut enim ad minim veniam.</mj-text>
          <mj-button align="left" background-color="#e85034" color="#fff" border-radius="24px" font-size="11px" href="${buttonUrl}" font-family="Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif" padding-bottom="45px" padding-top="10px">READ MORE</mj-button>
        </mj-column>
      </mj-section>
      <mj-section full-width="full-width">
        <mj-column width="100%" vertical-align="middle">
          <mj-text align="center" font-size="11px" padding-bottom="0px" padding-top="0px">
          <p style="font-size: 11px">
          Please contact us if you have any questions. 
          </mj-text>
        </mj-column>
      </mj-section>
    </mj-body>
  </mjml>
    `));
}
```

3. And as final step, we need to define the workflow that uses the template defined above.

```jsx theme={null}
import { Client, workflow } from "@novu/framework";
import { mjmlTemplate } from "./mjml";

export const client = new Client({
  apiKey: process.env.NOVU_API_KEY,
  strictAuthentication: process.env.NODE_ENV !== "development",
});

export const emailWorkflow = workflow('mjml-email-workflow', async ({ payload, step }) => {
  await step.email('send-email', async (inputs) => {
    return {
      subject: `Welcome to MJML with Novu Framework, ${payload.text}!`,
      body: mjmlTemplate(inputs).html,
    };
  }, {
    inputSchema: {
      type: 'object',
      properties: {
        text: { type: 'string', default: 'Welcome to our service' },
        imageUrl: { type: 'string', default: 'https://picsum.photos/id/11/2000/300' },
        buttonText: { type: 'string', default: 'Sign up' },
        buttonUrl: { type: 'string', default: 'https://novu.co' },
      },
      additionalProperties: false,
    } as const
  });
}, {
  payloadSchema: {
    properties: {
      text: { type: 'string', default: 'Sumit' },
    },
    additionalProperties: false,
  }
});
```

Once you do this, you’ll see this workflow, the steps in the workflow, step inputs, payload variables and the rendered view of this workflow on the Echo Dev Studio:

<Frame>
  <img />
</Frame>

Here, from the Dev Studio, you or your peers can change things like the text of a button, toggle visibility of a button, static text content etc and have it synced with the cloud with the `Sync to Cloud` button.

### Payload vs Step Inputs

Notice that in the Echo dev studio above, we’ve used payload as well as step inputs. Here’s how you can decide if you need either or both:

| Payload                                                                                                                               | Step Inputs                                                                                                                                                                             |
| ------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| is used for dynamic content that changes from one notification to another based on events occurring in your system.                   | are used for static elements or predefined options that non-technical team members can modify without altering the codebase.                                                            |
| is controlled by developers and passed dynamically through the novu.trigger method.                                                   | are defined by developers but aremeant to be utilized and modified by non-technical peers.                                                                                              |
| Payload examples include User ID, Post ID, Comment, Order ID, 2FA token, etc., which are likely to change with each notification.     | Step Inputs examples include the text of a button, whether a section should be shown, static text content, etc., which are generally static but configurable elements.                  |
| Payload modifications are made in the code by developers at the time of triggering a notification.                                    | Step Inputs can be modified directly in the UI, offering a no-code solution for non-technical team members to make changes.                                                             |
| Payload data is passed during the novu.trigger method and is part of the dynamic data handling process within notification workflows. | Step Inputs are predefined in the workflow configuration and can be adjusted through the Echo Dev Studio, affecting how notifications are rendered without changing the workflow logic. |

## Syncing with the cloud, with the click of a button

Once done with the workflow, now we need to sync it to the cloud. Fortunately, Novu Framework makes it a breeze to sync changes from the local machine to the cloud and it all happens with a click of a button.

To enable our cloud environment to talk to your local Bridge instance, you need to supply an Bridge endpoint URL. This sets up a communication channel between our cloud environment and your local instance. To allow Novu to communicate with your local machine a tunnel will need to be generated.

The `create-novu-app` command sets up `localtunnel` for you. Running the `npm run dev` script in the project launches both the Bridge application and the tunnel solution. The tunnel URL shows up in the console output.

You can also use a tool like `ngrok`:

```bash theme={null}
// using ngrok 
ngrok http http://localhost:<YOUR_EDGE_PORT>      
```

In our case, the app is running on port 4000 so we’ll use:

```bash theme={null}
ngrok http http://localhost:4000
```

This will create a tunnel and you’ll see something like this in the terminal:

<Frame>
  <img />
</Frame>

Remember, the exact URL (`/api/novu` or similar) you expose in your application for handling Novu Framework requests is what you'd consider the `Bridge URL`.

This URL would be the endpoint within your application's domain where Novu's Worker Engine sends requests to fetch notification content or subscriber details dynamically. In our case, it is this: [https://faec-2409-40f2-3c-3b57-400e-a7f7-1fc0-1e5.ngrok-free.app/api/echo](https://faec-2409-40f2-3c-3b57-400e-a7f7-1fc0-1e5.ngrok-free.app/api/echo)
So, we’ll enter this Bridge URL:

<Frame>
  <img />
</Frame>

And create diff:

<Frame>
  <img />
</Frame>

## Testing our workflow

Once you’ve synced your changes in the previous step, you’ll see a notification that says ‘Sync complete’ and you can now go to Novu Cloud using the ‘Test your workflows’ link and trigger a notification.

<Frame>
  <img />
</Frame>

You’ll see the workflow you’ve created has a blue lightning bolt icon. That icon signifies that the corresponding workflow has been created with Novu Framework:

<Frame>
  <img />
</Frame>

Simply open the workflow and you can send a test email from there.

<Note>
  Make sure that all the expected payload variables and step inputs are being sent in their respective fields!
</Note>

<Frame>
  <img />
</Frame>

This is the workflow test email in my inbox:

<Frame>
  <img />
</Frame>

Once tested, you can simply have this workflow triggered whenever you want. For instance, a typical use case is to have a workflow triggered when an event occurs. To replicate it, I’ve attached a handler function that triggers this workflow when the `submit` event fires:

Here’s a simple replication of the stipulated scenario:

```jsx theme={null}
'use client';

import { useState } from 'react';

export default function Home() {
  const [loading, setLoading] = useState(false);
  const [text, setText] = useState('')
  const [email, setEmail] = useState('')


  const triggerWorkflow = async () => {
    setLoading(true);
    const response = await fetch('/api/users', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        text: text,
        email: email
      }),
    });
    const result = await response.json();
    setLoading(false);
    console.log(result);
  };
  return (
    <div>
      <h1>MJML Email with Novu Framework</h1>
      <input placeholder='Enter customer name' onChange={e => setText(e.target.value)} value={text} />
      <input placeholder='Enter customer email' onChange={e => setEmail(e.target.value)} value={email} />
      <button onClick={triggerWorkflow} disabled={loading}>
        {loading ? 'Sending...' : 'Send Email'}
      </button>
    </div>
  );
}

```

And the corresponding route it hits:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<Your Novu API Key>');

export async function POST(request: Request) {
  const res = await request.json();

  await novu.trigger('mjml-email-workflow', {
    to: {
      subscriberId: 'novu-sub-two',
      email: res.email
    },
    payload: {
      text: res.text,
    },
  });

  console.log('triggered')
  return Response.json({ success: true });
}
```

So there you go!

This is how you create workflows using Novu Framework and deploy your changes seamlessly to the Novu cloud. You can check out the code for a [sample demo app](https://github.com/novuhq/framework-mjml).

Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows.

Don’t forget to share your workflows with us and as always, hit us up on Discord with any questions you might have!


# How to send notifications with Nuxt.js and Vuemail
Source: https://v0.x-docs.novu.co/guides/framework-guides/framework-nuxt-vuemail

Learn how to send email notifications with Nuxt.js, Vuemail and Novu

This guide assumes you know what [a notification workflow](https://docs.novu.co/workflows/notification-workflows) is and why you need it. It also assumes you are aware of [Nuxt](https://nuxt.com/) and [VueEmail](https://vuemail.net/).
Fantastic. Now that we are all on the same page let’s proceed.

Novu recently released a new way of baking notification workflows into your apps via code, and it’s huge! Let me walk you through it.

It’s called Novu Framework and you can learn more about it by visiting the related [documentation](https://docs.novu.co/framework/quickstart). You might also benefit from reading this excellent [Code-First Approach to Managing Notification Workflows](https://novu.co/blog/a-code-first-approach-to-managing-notification-workflows/) article.

If you prefer to clone the repository from GitHub and get your hands dirty, we aren’t going to stop you. You can find it [here](https://github.com/novuhq/novu-framework-nuxt-vue-email-example).

Still here? Good, I wrote this guide for you!

## Getting Started

## 1. Initialize **New Nuxt Project**

We will follow the [official installation guide from Nuxt](https://nuxt.com/docs/getting-started/installation), open your terminal / IDE, and run the following command:

```jsx theme={null}
npx nuxi@latest init <project-name>
```

## 2. **Integrate Novu Framework Into Our App (Notification Workflow)**

1. We will install the `@novu/framework` package in the root of our Nuxt app directory by running the following command:

```jsx theme={null}
npm install @novu/framework
```

2. We must provide an API endpoint for the [Novu Dev Studio](https://docs.novu.co/framework/concepts/studio) to fetch our notification workflow. (Don’t worry; we guide you through all the steps.) Navigate to your app's `app/server` directory and create a new directory named `api`.

```jsx theme={null}
cd app/server

mkdir api
```

Create a file within the `app/server/api` directory and name it `novu.ts`.  Copy and paste the code snippet below:

```jsx theme={null}
// app/server/api/novu.ts
import { serve } from "@novu/framework/nuxt";
import { client, myWorkflow } from "../novu/workflows";

export default defineEventHandler(serve({ client: client, workflows: [myWorkflow] }));
```

3. Now, let's create the instance where we will build and maintain our notification workflow:

Navigate to your `app/server` directory and create another directory named `novu`.

```jsx theme={null}
cd app/server

mkdir novu
```

Create a file within the `app/server/novu` directory and name it `workflows.ts`.  Copy and paste the code snippet below:

```jsx theme={null}
// app/server/novu/workflows.ts
// This workflow already renders vue email template.

import { config } from '@vue-email/compiler'
import { Client, workflow } from '@novu/framework';

const vueEmail = config('templates', {
  verbose: false,
  options: {
  },
})

export const client = new Client({
  /**
   * Disable this flag only during local development
   * For production this should be true
   */
  strictAuthentication: process.env.NODE_ENV !== "development"
});

export const myWorkflow = workflow('hello-world', async ({ step, payload }) => {
    await step.email(
        'send-email',
        async () => {
            const template = await vueEmail.render('sample-email.vue', {
                props: payload,
            });
            return {
                subject: `You have a new invitation from: ${payload.username}.`,
                body: template.html,
            }
        });
},
    {
        payloadSchema: {
            // Always `object`
            type: 'object',
            // Specify the properties to validate. Supports deep nesting.
            properties: {
                        username: { type: "string" },
                        invitedByEmail: { type: "string" },
                        inviteLink: { type: "string" },
                        inviteFromIp: { type: "string" },
                        inviteFromLocation: { type: "string" }
            },
            // Used to enforce full type strictness, with no rogue properties.
            additionalProperties: false,
            // The `as const` is important to let Typescript know that this
            // type won't change, enabling strong typing on `inputs` via type
            // inference of the provided JSON Schema.
        } as const,
    },
);
```

We haven’t finished the guide yet but have everything to build a notification workflow.

Below, We can see a “plain” Client instance and shaping your desired workflow.

```jsx theme={null}
// app/server/novu/workflows.ts
// This is Client instance concept - not a working instance!

import { Client, workflow } from '@novu/framework';

export const client = new Client({
  /**
   * Disable this flag only during local development
   * For production this should be true
   */
  strictAuthentication: process.env.NODE_ENV !== "development"
});

export const myWorkflow = workflow(
	'<WORKFLOW_NAME>', // The Workflow name. Must be unique across your Bridge application.
	// Workflow resolver, the entry-point for your Workflow steps
	async ({
		// Helper function to declare your Workflow Steps.
		step,
		// Workflow Trigger payload
		payload,
	}) => {
	// ...your Workflow Steps
}, {
	// JSON Schema for validation and type-safety. Zod, and others coming soon.
	// https://json-schema.org/draft-07/json-schema-release-notes

	// The schema for the Workflow payload passed dynamically via Novu Trigger API
	// Defaults to an empty schema.
	payloadSchema: { properties: { name: { type: 'string' }}},
	// The schema for the Workflow inputs passed statically via Novu Web
	// Defaults to an empty schema.
	inputSchema: { properties: { brandColor: { type: 'string' }}},
});
```

We can:

* Select a name for our workflow.
* Declare [Workflow Steps](https://docs.novu.co/framework/steps/introduction) as we see fit for our use case
* Configure what could be passed in the payload of the Workflow Trigger ([payloadSchema](https://docs.novu.co/framework/concepts/inputs))
* Configure what inputs could be passed statically via Novu Web ([inputSchema](https://docs.novu.co/framework/concepts/inputs))

Note: You can create and manage as many workflows as you wish within `app/server/novu/workflows.ts`; make sure to provide each workflow with a unique name.

## 3. Adding Vuemail in our notification workflow

1. We will install the `vue-email` package in the root of our Nuxt app directory by running the following command:

```jsx theme={null}
npm install vue-email
```

2. We will create one more directory in the root of our directory and name it `templates`. That is where our vue-email templates will be stored.

```c theme={null}
mkdir templates
```

3. In the `app/templates` directory, we will create a file for our first vue-email template and name it `sample-email.vue`.

[You can find examples of Vue email templates here.](https://vuemail.net/playground)

```jsx theme={null}
// app/templates/sample-email.vue

<script setup lang="ts">
import { defineProps, withDefaults } from 'vue'

interface Props {
  invitedByUsername?: string
  teamName?: string
  username?: string
  invitedByEmail?: string
  inviteLink?: string
  inviteFromIp?: string
  inviteFromLocation?: string
  showFootnote?: boolean;
  components: string[] | null
}

const baseUrl = "https://react-email-demo-bdj5iju9r-resend.vercel.app";

const props = withDefaults(defineProps<Props>(), {
  teamName: 'Cleaning',
  username: 'John Doe',
  invitedByEmail: 'anpch@example.com',
  inviteLink: 'https://acme.com/projects/accept/foo',
  inviteFromIp: '172.0.0.1',
  inviteFromLocation: 'San Francisco, CA',
  showFootnote: true,
  components: null
})

const previewText = `Join ${props.invitedByUsername} on Vercel`
</script>

<template>
  <ETailwind>
    <EHtml>
      <EHead />
      <EPreview>{{ previewText }}</EPreview>
      <EBody class="bg-white my-auto mx-auto font-sans">
        <EContainer class="border border-solid border-[#eaeaea] p-[20px] md:p-7 rounded my-[40px] mx-auto max-w-[465px]">
          <div v-for="item in components || []">
            <EButton v-if="item === 'button'" px="20" py="12" class="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center" :href="inviteLink"> Accept </EButton>
            <EText v-if="item === 'text'" class="text-black text-[14px] leading-[24px]"> Hello {{ username }}, </EText>
            <EHr v-if="item === 'divider'" class="border border-solid border-[#eaeaea] my-[26px] mx-0 w-full" />
          </div>
          <ESection class="mt-[32px]">
            <EImg :src="`${baseUrl}/static/vercel-logo.png`" width="40" height="37" alt="Vercel" class="my-0 mx-auto" />
          </ESection>
          <Hello />
          <EHeading class="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
            New Project <strong>{{ teamName }}</strong> available
          </EHeading>
          <EText class="text-black text-[14px] leading-[24px]"> Hello {{ username }}, </EText>
          <EText class="text-black text-[14px] leading-[24px]">
            <strong>{{invitedByUsername}}</strong> (
            <ELink :href="`mailto:${invitedByEmail}`" class="text-blue-600 no-underline">
              {{ invitedByEmail }}
            </ELink>
            ) has invited you to the <strong>{{ teamName }}</strong> project on <strong>Acme</strong>.
          </EText>
          <ESection>
            <ERow>
              <EColumn align="right">
                <EImg class="rounded-full" :src="`${baseUrl}/static/vercel-user.png`" width="64" height="64" />
              </EColumn>
              <EColumn align="center">
                <EImg :src="`${baseUrl}/static/vercel-arrow.png`" width="12" height="9" alt="invited you to" />
              </EColumn>
              <EColumn align="left">
                <EImg class="rounded-full" :src="`${baseUrl}/static/vercel-team.png`" width="64" height="64" />
              </EColumn>
            </ERow>
          </ESection>
          <ESection class="text-center mt-[32px] mb-[32px]">
            <EButton px="20" py="12" class="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center" :href="inviteLink"> Accept </EButton>
            <EButton px="20" py="12" class="rounded text-[12px] font-semibold no-underline text-center" :href="inviteLink"> Decline </EButton>

          </ESection>
          <EText class="text-black text-[14px] leading-[24px]">
            or copy and paste this URL into your browser:
            <ELink :href="inviteLink" class="text-blue-600 no-underline">
              {{ inviteLink }}
            </ELink>
          </EText>

          <EHr class="border border-solid border-[#eaeaea] my-[26px] mx-0 w-full" />
          <EText v-if="showFootnote" class="text-[#666666] text-[12px] leading-[24px]">
            This invitation was intended for
            <span class="text-black">{{ username }} </span>.This invite was sent from <span class="text-black">{{ inviteFromIp }}</span> located in
            <span class="text-black">{{ inviteFromLocation }}</span
            >. If you were not expecting this invitation, you can ignore this email. If you are concerned about your account's safety, please reply to this email to get in touch
            with us.
          </EText>

        </EContainer>
      </EBody>
    </EHtml>
  </ETailwind>
</template>
```

## 4. Launching The Dev Studio

Now that we have everything in our notification workflow configured along with the vue-email template we will use, it’s time to see a visual representation of what we have built.

1. If you haven’t run the development environment for your Nuxt app, now is the time.

   ```jsx theme={null}
   npm run dev
   ```

2. Do you remember that we exposed an Bridge API endpoint in our app for Dev Studio to catch? This is where it happens.

   Run the following command in a separate terminal:

   ```jsx theme={null}
   npx novu-labs@latest echo
   ```

   If you’ve followed this guide, you should see this:

   <Frame>
     <img />
   </Frame>

   Here is where our exact API endpoint goes. If our application runs on a different port, we should change the URL manually to point Dev Studio in the right direction.

   <Frame>
     <img />
   </Frame>

   Also, if we have configured everything correctly, we should see that Dev Studio sees our workflow identifier (Workflow unique name).

   <Frame>
     <img />
   </Frame>

3. Click the “View Workflow” button in the Dev Studio to see the workflow.

   We should see the following:

   <Frame>
     <img />
   </Frame>

Click on the workflow step node called `send-email`. We should see a preview of our email template and the `Step Input` and `Payload` variables we have configured in the workflow schemas.

<Frame>
  <img />
</Frame>

4. This is the time to adjust the email template, step input schema, or define the properties we anticipate in the payload. We have a live representation of everything. You can add more steps like In-App, SMS, and chat.

## 5. Syncing our workflow to Novu Cloud

Having completed crafting, designing, and modifying our notification workflow to suit our requirements, we're ready to push it to Novu Cloud. There, it will handle the heavy lifting and seamlessly execute all the steps we've configured whenever we trigger the workflow.

1. Click on the `Sync to Cloud` button on the top right.

   <Frame>
     <img />
   </Frame>

2. We will need to create a local tunnel that the Novu Cloud environment can reach for local experimentation purposes.

   <Frame>
     <img />
   </Frame>

   On a separate terminal, run the following command:

   ```jsx theme={null}
   // Change to the port where the app is currently running

   npx localtunnel --port 3000
   ```

   We should get something like:

   ```jsx theme={null}
   your url is: https://famous-pumas-clap.loca.lt
   ```

   <Frame>
     <img />
   </Frame>

3. Click the `Create Diff` button. To push (merge) the workflow code to the cloud, an API Key from our Novu account should be added to our Framework Client instance.

   <Frame>
     <img />
   </Frame>

   Let’s navigate to `../app/server/novu/workflows.ts` file and add our Novu API Key.

```jsx theme={null}
// app/server/novu/workflows.ts
// This workflow already renders vue email template.

import { config } from '@vue-email/compiler'
import { Client, workflow } from '@novu/framework';

const vueEmail = config('templates', {
  verbose: false,
  options: {
  },
})

export const client = new Client({
  apiKey: process.env.NOVU_API_KEY, // <<-- Your Novu API KEY
  /**
   * Disable this flag only during local development
   * For production this should be true
   */
  strictAuthentication: process.env.NODE_ENV !== "development"
});

export const myWorkflow = workflow('hello-world', async ({ step, payload }) => {
    await step.email(
        'send-email',
        async () => {
            const template = await vueEmail.render('sample-email.vue', {
                props: payload,
            });
            return {
                subject: `You have a new invitation from: ${payload.username}.`,
                body: template.html,
            }
        });
},
    {
        payloadSchema: {
            // Always `object`
            type: 'object',
            // Specify the properties to validate. Supports deep nesting.
            properties: {
                        username: { type: "string" },
                        invitedByEmail: { type: "string" },
                        inviteLink: { type: "string" },
                        inviteFromIp: { type: "string" },
                        inviteFromLocation: { type: "string" }
            },
            // Used to enforce full type strictness, with no rogue properties.
            additionalProperties: false,
            // The `as const` is important to let Typescript know that this
            // type won't change, enabling strong typing on `inputs` via type
            // inference of the provided JSON Schema.
        } as const,
    },
);
```

We will now click the `Create Diff` button again.

<Frame>
  <img />
</Frame>

This is where you can review all the changes made to the workflow. Once you have verified that everything is in order, go ahead and click the `Deploy Changes` button.

<Frame>
  <img />
</Frame>

## 6. Testing Our Notification Workflow

There are many ways to test and [trigger our workflow](https://docs.novu.co/api-reference/events/trigger-event), but we'll make a `cURL` API call to Novu Cloud from our terminal in this guide.

If we don't have any subscribers or users in our database or within our Novu Cloud organization, we'll send the test to ourselves for simplicity.

* In the `subscriberId` key, input a random number or even our email address (as long as we do not try to assign the same ID key to another subscriber, we should be good).
* For the `email` key, we will need to insert a valid email address so we can actually receive the email.

<Info>**Note:** Learn more about the structure of [subscriber properties](https://docs.novu.co/subscribers/subscribers).</Info>

We can leave the payload empty or add properties aligned with the `payloadSchema` we established in the workflow definition.

```jsx theme={null}

curl -X POST https://api.novu.co/v1/events/trigger \
  -H "Authorization: ApiKey <NOVU_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "hello-world",
    "to": {
      "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      "email": "john@doemail.com",
    },
    "payload": {
        "username": "Jane Doe",
		    "invitedByEmail": "Jane@doemail.com",
		    "inviteLink": "https://acme.com/projects/accept/foo",
		    "inviteFromIp": "172.0.0.1",
		    "inviteFromLocation": "New York, DC"
    }
  }'

```

Now, let’s check our email inbox.

* No longer limited by UI notification steps and rigidity.
* No longer limited by notification content editors and systems. The more, the merrier!
* Now an IFTTT (If-This-Then-That) pro engineer!

Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows. Have fun, and share your use case on Discord with us!


# How to send notifications with Next.js and React email
Source: https://v0.x-docs.novu.co/guides/framework-guides/framework-react-email

Leverage the React email package to send email notifications

# Introduction

In this guide, you’ll learn how to send email notifications using the React email package. But before we jump into it, let's first take a look at the prerequisites!

## Pre-requisites

* A Novu account
* Node installed on your machine
* A working NextJS development environment

## Get started with Novu Framework

[Novu Framework](https://docs.novu.co/framework/quickstart) is a "notifications as code" approach that enables developers to define workflows as functions and integrate them with their preferred libraries for email, SMS, and chat generation.

1. To get started with Novu Framework, just run this command in your terminal, it’ll scaffold a new NextJS project with Novu Framework and we’ll be ready to roll!

```jsx theme={null}
npx create-novu-app --api-key=<YOUR_API_KEY>
```

2. Once you execute this command, you’ll be asked to give your project a name. I’ll keep the default `my-novu-app` but you can choose your own.

<Frame>
  <img />
</Frame>

3. You’ll then be asked if you want to use React-email or not. You can choose to install it at this step itself or proceed with No and then install it later. I’m choosing the default No option.

<Frame>
  <img />
</Frame>

4. After this step, all the dependencies will be installed and you will be able to start using Novu Framework.

<Frame>
  <img />
</Frame>

5. Once this installation is complete, simply cd into the directory and start your app using the `npm run dev` command, and your app will be served on `localhost:4000`

<Note>
  Make sure that the port 4000 isn’t already being used!
</Note>

You’ll now have a NextJS app running on `http://localhost:4000` and you can make changes to your app as you see fit. Let’s now move to the meaty stuff - using Novu Framework in a NextJS app and the magic of Dev Studio.

## Echo Dev Studio

The Echo Dev Studio is a companion app to the Echo Client SDK. Its goal is to provide a local environment that lives near your code.

To launch the dev studio locally you can run: `npx novu-labs@latest echo`. The Dev Studio will be started by default on port `2022`, and accessible via: `http://localhost:2022`

<Frame>
  <img />
</Frame>

Here’s how the Dev Studio looks on the first run:

<Frame>
  <img />
</Frame>

You’ll notice that it asks for an `Bridge endpoint` at the bottom. Novu Framework requires a single HTTP endpoint (`/api/novu` or similar) to be exposed by your application. This endpoint is used to receive events from our Worker Engine. We have more on Bridge endpoint [in our docs.](https://docs.novu.co/framework/concepts/endpoint)

<Note>
  You can view the Bridge Endpoint as a webhook endpoint that Novu will call when it needs to retrieve contextual information for a given subscriber and notification.
</Note>

Just enter the full URL of your Bridge Endpoint. In our case, it is `http://localhost:4000/api/echo`

<Frame>
  <img />
</Frame>

Once you do, you’ll see a green checkmark alongside the URL input box and a green `connected` highlight at the top right corner.

## Installing and configuring React Email

<Note>
  If you opted for installing React Email in our CLI set-up process, you can skip installing it again.
</Note>

Integrating React Email with Novu in our NextJS app is quite straightforward. Following are the steps to get it installed and configured:

1. Simply run the following command to install it like any other npm package:

```jsx theme={null}
  npm i @react-email/components react-email
```

Once installed, proceed to write an email template in the next step

2. To write an email template, you can look over some of the examples in the [React Email documentation](https://react.email/examples) to get inspiration. In our case, this is the template:

```jsx theme={null}
import {
  Body,
  Button,
  Container,
  Column,
  Head,
  Hr,
  Html,
  Img,
  Link,
  render,
  Row,
  Section,
  Text,
  Tailwind,
} from "@react-email/components";
import * as React from "react";

interface VercelInviteUserEmailProps {
  username?: string;
  userImage?: string;
  invitedByUsername?: string;
  invitedByEmail?: string;
  teamName?: string;
  teamImage?: string;
  inviteLink?: string;
  inviteFromIp?: string;
  showJoinButton?: boolean;
  inviteFromLocation?: string;
  buttonText?: string
}

const baseUrl = process.env.VERCEL_URL
  ? `https://${process.env.VERCEL_URL}`
  : "";

export const VercelInviteUserEmail = ({
  username,
  userImage,
  invitedByUsername,
  invitedByEmail,
  teamName,
  teamImage,
  inviteLink,
  inviteFromIp,
  inviteFromLocation,
  showJoinButton,
  buttonText
}: VercelInviteUserEmailProps) => {

  return (
    <Html>
      <Head />
      <Tailwind>
        <Body className="bg-white my-auto mx-auto font-sans px-2">
          <Container className="border border-solid border-[#eaeaea] rounded my-[40px] mx-auto p-[20px] max-w-[465px]">
            <Section className="mt-[32px]">
              <Img
                src={`https://react-email-demo-ndjnn09xj-resend.vercel.app/static/vercel-logo.png`}
                width="40"
                height="37"
                alt="Vercel"
                className="my-0 mx-auto"
              />
            </Section>
            <Text className="text-black text-[14px] leading-[24px]">
              Hello {username},
            </Text>
            <Text className="text-black text-[14px] leading-[24px]">
              <strong>{invitedByUsername}</strong> (
              <Link
                href={`mailto:${invitedByEmail}`}
                className="text-blue-600 no-underline"
              >
                {invitedByEmail}
              </Link>
              ) has invited you to the <strong>{teamName}</strong> team on{" "}
              <strong>Vercel</strong>.
            </Text>
            <Section>
              <Row>
                <Column align="right">
                  <Img
                    className="rounded-full"
                    src={userImage}
                    width="64"
                    height="64"
                  />
                </Column>
                <Column align="center">
                  <Img
                    src={`https://react-email-demo-ndjnn09xj-resend.vercel.app/static/vercel-arrow.png`}
                    width="12"
                    height="9"
                    alt="invited you to"
                  />
                </Column>
                <Column align="left">
                  <Img
                    className="rounded-full"
                    src={teamImage}
                    width="64"
                    height="64"
                  />
                </Column>
              </Row>
            </Section>
            {showJoinButton && (
              <Section className="text-center mt-[32px] mb-[32px]">
                <Button
                  className="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center px-5 py-3"
                  href={inviteLink}
                >
                  {buttonText}
                </Button>
              </Section>
            )}
            <Text className="text-black text-[14px] leading-[24px]">
              or copy and paste this URL into your browser:{" "}
              <Link href={inviteLink} className="text-blue-600 no-underline">
                {inviteLink}
              </Link>
            </Text>
            <Hr className="border border-solid border-[#eaeaea] my-[26px] mx-0 w-full" />
            <Text className="text-[#666666] text-[12px] leading-[24px]">
              This invitation was intended for{" "}
              <span className="text-black">{username}</span>. This invite was
              sent from <span className="text-black">{inviteFromIp}</span>{" "}
              located in{" "}
              <span className="text-black">{inviteFromLocation}</span>. If you
              were not expecting this invitation, you can ignore this email. If
              you are concerned about your account's safety, please reply to
              this email to get in touch with us.
            </Text>
          </Container>
        </Body>
      </Tailwind>
    </Html>
  );
};

VercelInviteUserEmail.PreviewProps = {
  username: "alanturing",
  userImage: `${baseUrl}/static/vercel-user.png`,
  invitedByUsername: "Alan",
  invitedByEmail: "alan.turing@example.com",
  teamName: "Enigma",
  teamImage: `${baseUrl}/static/vercel-team.png`,
  inviteLink: "https://vercel.com/teams/invite/foo",
  inviteFromIp: "204.13.186.218",
  inviteFromLocation: "São Paulo, Brazil",
} as VercelInviteUserEmailProps;

export default VercelInviteUserEmail;

export function renderReactEmail(input: any, payload: any) {
  return render(<VercelInviteUserEmail {...input}{...payload} />);

}
```

3. And as final step, we need to define the workflow that uses the template defined above.

```jsx theme={null}
export const newSignup = workflow('new-signup', async ({ step, payload }) => {
  // Send a welcome email
  await step.email('send-email', async (inputs) => {
    return {
      subject: `Welcome to Novu, ${payload.username}`,
      body: renderReactEmail(inputs, payload),
    };
  }, {
    inputSchema: {
      type: "object",
      properties: {
        showJoinButton: { type: "boolean", default: true },
        buttonText: { type: "string", default: "Join the team" },
        userImage: {
          type: "string",
          default: "https://react-email-demo-bdj5iju9r-resend.vercel.app/static/vercel-user.png",
          format: "uri",
        },
        invitedByUsername: { type: "string", default: "Alan" },
        invitedByEmail: {
          type: "string",
          default: "alan.turing@example.com",
          format: "email",
        },
        teamName: { type: "string", default: "Team Awesome" },
        teamImage: {
          type: "string",
          default: "https://react-email-demo-bdj5iju9r-resend.vercel.app/static/vercel-team.png",
          format: "uri",
        },
        inviteLink: {
          type: "string",
          default: "https://vercel.com/teams/invite/foo",
          format: "uri",
        },
        inviteFromIp: { type: "string", default: "204.13.186.218" },
        inviteFromLocation: {
          type: "string",
          default: "São Paulo, Brazil",
        },
      },
    },
  });
  // JSON Schema for validation and type-safety. Zod, and others coming soon.
}, { payloadSchema: { properties: { text: { type: 'string' } } } });
```

Once you do this, you’ll see this workflow, the steps in the workflow, step inputs, payload variables and, the rendered view of this workflow on the Echo Dev Studio:

<Frame>
  <img />
</Frame>

Here, from the Dev Studio, you or your peers can change things like the text of a button, toggle visibility of a button, static text content, etc, and have it synced with the cloud with the `Sync to Cloud` button.

### Payload vs Step Inputs

Notice that in the Echo dev studio above, we’ve used payload as well as step inputs. Here’s how you can decide if you need either or both:

* Payload is used for dynamic content that changes from one notification to another based on events occurring in your system.
* Step Inputs are for static elements or predefined options that non-technical team members can modify without altering the codebase.
* Payload is controlled by developers and passed dynamically through the novu.trigger method.
* Step Inputs are defined by developers but are meant to be utilized and modified by non-technical peers.
* Payload examples include User ID, Post ID, Comment, Order ID, 2FA token, etc., which are likely to change with each notification.
* Step Inputs examples include the text of a button, whether a section should be shown, static text content, etc., which are generally static but configurable elements.
* Payload modifications are made in the code by developers at the time of triggering a notification.
* Step Inputs can be modified directly in the UI, offering a no-code solution for non-technical team members to make changes.
* Payload data is passed during the novu.trigger method and is part of the dynamic data handling process within notification workflows.
* Step Inputs are predefined in the workflow configuration and can be adjusted through the Echo Dev Studio, affecting how notifications are rendered without changing the workflow logic.

## Syncing with the cloud, with the click of a button

Once done with the workflow, now we need to sync it to the cloud. Fortunately, Novu Framework makes it a breeze to sync changes from the local machine to the cloud and it all happens with a click of a button.

To enable our cloud environment to talk to your local Echo instance, you need to supply an Echo endpoint URL. This sets up a communication channel between our cloud environment and your local instance. To allow Novu to communicate with your local machine a tunnel will need to be generated.

The `create-novu-app` command sets up `localtunnel` for you. Running the `npm run dev` script in the project launches both the Bridge application and the tunnel solution. The tunnel URL shows up in the console output.

You can also use a tool like `ngrok`:

```bash theme={null}
// using ngrok 
ngrok http http://localhost:<YOUR_EDGE_PORT>      
```

In our case, the app is running on port 4000 so we’ll use:

```bash theme={null}
ngrok http http://localhost:4000
```

This will create a tunnel and you’ll see something like this in the terminal:

<Frame>
  <img />
</Frame>

Remember, the exact URL (`/api/novu` or similar) you expose in your application for handling Novu Framework requests is what you'd consider the `Bridge URL`.

This URL would be the endpoint within your application's domain where Novu's Worker Engine sends requests to fetch notification content or subscriber details dynamically. In our case, it is this: `https://0536-2409-40f2-1039-43e1-3053-d98e-c276-ee5.ngrok-free.app/api/echo`

So, we’ll enter this Bridge URL:

<Frame>
  <img />
</Frame>

And create diff:

<Frame>
  <img />
</Frame>

## Testing our workflow

Once you’ve synced your changes in the previous step, you’ll see a notification that says ‘Sync complete’ and you can now go to Novu Cloud using the ‘Test your workflows’ link and trigger a notification.

<Frame>
  <img />
</Frame>

You’ll see the workflow you’ve created has a blue lightning bolt icon. That icon signifies that the corresponding workflow has been created with Novu Framework:

<Frame>
  <img />
</Frame>

Simply open the workflow and you can send a test email from there.

<Note>
  Make sure that all the expected payload variables and step inputs are being sent in their respective fields!
</Note>

<Frame>
  <img />
</Frame>

This is the workflow test email in my inbox:

<Frame>
  <img />
</Frame>

Once tested, you can simply have this workflow triggered whenever you want. For instance, a typical use case is to have a workflow triggered when an event occurs. To replicate it, I’ve attached a handler function that triggers this workflow when the `submit` event fires:

Here’s a simple replication of the stipulated scenario:

```jsx theme={null}
"use client"
import Image from "next/image";
import styles from "./page.module.css";
import React, { useState } from "react";
import axios from "axios";

export default function Home() {

  const [email, setEmail] = useState('')
  const [username, setUsername] = useState('')

  const onClickHandler = async (e: React.FormEvent<HTMLFormElement>) => {
    try {
      e.preventDefault();
      await fetch("/api/users", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          email: email,
          username: username,
        }),
      });

      // console.log('working fine');
    } catch (error) {
      console.error('Error:', error);
    }
  };
  return (
    <main style={{ height: '100vh', display: 'flex', justifyContent: 'center', alignItems: 'center' }}>
      <form onSubmit={(e) => onClickHandler(e)}>
        <input
          placeholder="Enter email id"
          onChange={(e) => setEmail(e.target.value)}
          style={{
            // Add your CSS-in-JS styles here
            padding: '0.5rem',
            marginBottom: '1rem',
            borderRadius: '0.25rem',
            border: '1px solid #ccc',
            width: '100%',
            boxSizing: 'border-box',
          }}
        />
        <input
          placeholder="Enter the name of invitee"
          onChange={(e) => setUsername(e.target.value)}
          style={{
            // Add your CSS-in-JS styles here
            padding: '0.5rem',
            marginBottom: '1rem',
            borderRadius: '0.25rem',
            border: '1px solid #ccc',
            width: '100%',
            boxSizing: 'border-box',
          }}
        />
        <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'center' }}>

          <button
            style={{
              // Add your CSS-in-JS styles here
              padding: '0.5rem 1rem',
              backgroundColor: '#4CAF50',
              color: 'white',
              border: 'none',
              borderRadius: '0.25rem',
              cursor: 'pointer',
            }}
          >
            Submit
          </button>
        </div>
      </form>
    </main>
  );
}
```

And the corresponding route it hits:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<Your Novu API Key>');

export async function POST(request: Request) {
  const res = await request.json();

  await novu.trigger('<Workflow name>', {
    to: {
      subscriberId: '<subscriber ID>',
    },
    payload: {
      email: res.email,
      username: res.username,
    },
  });

  console.log('triggered')
  return Response.json({ success: true });
}
```

## More workflow examples

Creating workflows with Novu Framework is a breeze. Here are a couple of other examples from React email docs created with Novu Framework:

1. AWS Email verification example

<Frame>
  <img />
</Frame>

2. Apple invoice email example

<Frame>
  <img />
</Frame>

## Conclusion

So there you go!

This is how you create workflows using Novu Framework and deploy your changes seamlessly to the Novu cloud. You can check out the code for a [sample demo app](https://github.com/novuhq/novu-framework-nextjs-react-email-example).
Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows.

<br />

Don’t forget to share your workflows with us and as always, hit us up on Discord with any questions you might have!


# How to send notifications with Remix and React email
Source: https://v0.x-docs.novu.co/guides/framework-guides/framework-remix

Learn how to send email notifications with Remix, React email and Novu

# Introduction

Learn how to send notifications with Remix, React email and Novu. You can check out the complete code for a [working app](https://github.com/novuhq/novu-framework-remix-example).

## Prerequisites

* A Novu account
* Node installed on your machine
* A working Remix app

## Follow these Steps

### 1. Install all dependencies including react email components

```jsx theme={null}
  npm install @novu/framework @react-email/components react-email
```

### 2. Integrate Novu with Remix

Within the `app/routes` directory, create an `api.novu.tsx` file.

```jsx theme={null}
// app/routes/api.novu.tsx

import { serve } from "@novu/framework/remix";
import { client, signUpWorkflow } from "~/novu/workflows";

const handler = serve({
    client: client,
    workflows: [signUpWorkflow]
  });
  
export { handler as action, handler as loader };
```

### 3. Create an email template in your Remix app

Within the `app` directory, create an `emails` folder and add an email template file to it.

In this scenario, create a `vercel-invite-user.tsx` file and the code below to it:

```ts theme={null}
// app/emails/vercel-invite-user.tsx

import {
    Body,
    Button,
    Container,
    Column,
    Head,
    Heading,
    Hr,
    Html,
    Img,
    Link,
    render,
    Row,
    Section,
    Text,
    Tailwind,
  } from "@react-email/components";
  
  interface VercelInviteUserEmailProps {
    username?: string;
    userImage?: string;
    invitedByUsername?: string;
    invitedByEmail?: string;
    teamName?: string;
    teamImage?: string;
    inviteLink?: string;
    inviteFromIp?: string;
    showJoinButton?: boolean;
    inviteFromLocation?: string;
    buttonText?: string
  }
  
  const baseUrl = process.env.VERCEL_URL
    ? `https://${process.env.VERCEL_URL}`
    : "";
  
  export const VercelInviteUserEmail = ({
    username,
    userImage,
    invitedByUsername,
    invitedByEmail,
    teamName,
    teamImage,
    inviteLink,
    inviteFromIp,
    inviteFromLocation,
    showJoinButton,
    buttonText
  }: VercelInviteUserEmailProps) => {
  
    return (
      <Html>
        <Head />
        <Tailwind>
          <Body className="bg-white my-auto mx-auto font-sans px-2">
            <Container className="border border-solid border-[#eaeaea] rounded my-[40px] mx-auto p-[20px] max-w-[465px]">
              <Section className="mt-[32px]">
                <Img
                  src={`https://react-email-demo-ndjnn09xj-resend.vercel.app/static/vercel-logo.png`}
                  width="40"
                  height="37"
                  alt="Vercel"
                  className="my-0 mx-auto"
                />
              </Section>
              <Heading className="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
                Join <strong>{teamName}</strong> on <strong>Vercel</strong>
              </Heading>
              <Text className="text-black text-[14px] leading-[24px]">
                Hello {username},
              </Text>
              <Text className="text-black text-[14px] leading-[24px]">
                <strong>{invitedByUsername}</strong> (
                <Link
                  href={`mailto:${invitedByEmail}`}
                  className="text-blue-600 no-underline"
                >
                  {invitedByEmail}
                </Link>
                ) has invited you to the <strong>{teamName}</strong> team on{" "}
                <strong>Vercel</strong>.
              </Text>
              <Section>
                <Row>
                  <Column align="right">
                    <Img
                      className="rounded-full"
                      src={userImage}
                      width="64"
                      height="64"
                    />
                  </Column>
                  <Column align="center">
                    <Img
                      src={`https://react-email-demo-ndjnn09xj-resend.vercel.app/static/vercel-arrow.png`}
                      width="12"
                      height="9"
                      alt="invited you to"
                    />
                  </Column>
                  <Column align="left">
                    <Img
                      className="rounded-full"
                      src={teamImage}
                      width="64"
                      height="64"
                    />
                  </Column>
                </Row>
              </Section>
              {showJoinButton && (
                <Section className="text-center mt-[32px] mb-[32px]">
                  <Button
                    className="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center px-5 py-3"
                    href={inviteLink}
                  >
                    {buttonText}
                  </Button>
                </Section>
              )}
              <Text className="text-black text-[14px] leading-[24px]">
                or copy and paste this URL into your browser:{" "}
                <Link href={inviteLink} className="text-blue-600 no-underline">
                  {inviteLink}
                </Link>
              </Text>
              <Hr className="border border-solid border-[#eaeaea] my-[26px] mx-0 w-full" />
              <Text className="text-[#666666] text-[12px] leading-[24px]">
                This invitation was intended for{" "}
                <span className="text-black">{username}</span>. This invite was
                sent from <span className="text-black">{inviteFromIp}</span>{" "}
                located in{" "}
                <span className="text-black">{inviteFromLocation}</span>. If you
                were not expecting this invitation, you can ignore this email. If
                you are concerned about your account's safety, please reply to
                this email to get in touch with us.
              </Text>
            </Container>
          </Body>
        </Tailwind>
      </Html>
    );
  };
  
  VercelInviteUserEmail.PreviewProps = {
    username: "alanturing",
    userImage: `${baseUrl}/static/vercel-user.png`,
    invitedByUsername: "Alan",
    invitedByEmail: "alan.turing@example.com",
    teamName: "Enigma",
    teamImage: `${baseUrl}/static/vercel-team.png`,
    inviteLink: "https://vercel.com/teams/invite/foo",
    inviteFromIp: "204.13.186.218",
    inviteFromLocation: "São Paulo, Brazil",
  } as VercelInviteUserEmailProps;
  
  export default VercelInviteUserEmail;
  
  export function renderEmail(input: any, payload: any) {
    return render(<VercelInviteUserEmail {...input}{...payload} />);
  }
```

### 4. Create a Novu Workflow

Next, create a Novu workflow with an email step. This code-first notification workflow approach makes it easy for product teams to modify notification content.

Within the `app` directory, create an `novu` folder and add a `workflows.ts` file to it. Copy/paste the code below to the recently created file.

```jsx theme={null}
// app/novu/workflows.ts

import { Client, workflow } from '@novu/framework';
import { renderEmail } from '~/emails/vercel-invite-user';

export const client = new Client({

  apiKey: process.env.NOVU_API_KEY,
  /**
   * Disable this flag only during local development
   * For production this should be true
   */
  strictAuthentication: process.env.NODE_ENV !== "development"
});

export const signUpWorkflow = workflow('new-signup', async ({ step, payload }) => {
  // Send a welcome email
  await step.email('send-email', async (inputs) => {
    return {
      subject: `Welcome to sending emails with Novu & Remix`,
      body: renderEmail(inputs, payload),
    };
  }, {
    inputSchema: {
      type: "object",
      properties: {
        showJoinButton: { type: "boolean", default: true },
        buttonText: { type: "string", default: "Join the team" },
        userImage: {
          type: "string",
          default: "https://react-email-demo-bdj5iju9r-resend.vercel.app/static/vercel-user.png",
          format: "uri",
        },
        invitedByUsername: { type: "string", default: "Alan" },
        invitedByEmail: {
          type: "string",
          default: "alan.turing@example.com",
          format: "email",
        },
        teamName: { type: "string", default: "Team Awesome" },
        teamImage: {
          type: "string",
          default: "https://react-email-demo-bdj5iju9r-resend.vercel.app/static/vercel-team.png",
          format: "uri",
        },
        inviteLink: {
          type: "string",
          default: "https://vercel.com/teams/invite/foo",
          format: "uri",
        },
        inviteFromIp: { type: "string", default: "204.13.186.218" },
        inviteFromLocation: {
          type: "string",
          default: "São Paulo, Brazil",
        },
      },
    },
  });
  // JSON Schema for validation and type-safety. Zod, and others coming soon.
}, { payloadSchema: { properties: { text: { type: 'string' } } } });
```

### 5. Preview Email Workflow & Sync to Novu Cloud

Open Novu Dev Studio to preview and make changes to the email workflow as needed via the command below:

```jsx theme={null}
npx novu-labs@latest echo
```

1. Run the Studio

<Frame>
  <img />
</Frame>

**Note:** Use the port on which your Remix app is running for the Bridge endpoint so that the Novu Dev Studio can connect to your API route as highlighted in the image above.

2. Check out the signup email workflow and test

<Frame>
  <img />
</Frame>

3. Deploy to Novu Cloud when you're done.

On the top right(as seen in the image above) of the Novu Dev Studio, you can sync to Novu Cloud when you're done working locally.

**Note:** You'll need to create a local tunnel that the Novu Cloud environment can reach for local experimentation purposes. Ngrok is a good tunnel.

### 6. Send a Notification

Trigger a notification using the recently deployed workflow either via your [Novu Cloud dashboard](https://web.novu.co) or [code](/quickstarts/react#trigger-a-notification).

```js theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<API_KEY>");

novu.trigger("new-signup", {
  to: {
    subscriberId: "789",
  }
});
```

Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows.


# How to send notifications with Svelte and Svelte email
Source: https://v0.x-docs.novu.co/guides/framework-guides/framework-svelte

Learn how to send email notifications with Svelte, Svelte email and Novu

# Introduction

Learn how to send notifications with Svelte, Svelte email and Novu. You can check out the complete code for a [working app](https://github.com/novuhq/novu-svelte-email).

## Prerequisites

* A Novu account
* Node installed on your machine
* A working SvelteKit app

## Follow these Steps

### 1. Install all dependencies

```jsx theme={null}
  npm install @novu/framework svelte-email
```

### 2. Integrate Novu with SvelteKit

Within the `src/routes` directory, create an `api/novu` folder and add a `+server.ts` file to it.

```jsx theme={null}
// src/routes/api/novu/+server.ts

import { svelteWorkflow, client } from '$lib/novu/workflows';
import { serve } from '@novu/framework/sveltekit';

export const { GET, POST, PUT } = serve({ client: client, workflows: [svelteWorkflow] });
```

### 3. Create an email template in Svelte

Within the `src/lib` directory, create an `emails` folder and add an email template in a `.svelte` file to it.

For example, `airbnb-review.svelte`:

```ts theme={null}
// src/lib/emails/airbnb-review.svelte

<script lang="ts">
	import {
		Button,
		Container,
		Head,
		Heading,
		Hr,
		Html,
		Img,
		Link,
		Preview,
		Section,
		Text
	} from 'svelte-email';

        const baseUrl = 'https://svelte-email-rjaapma15-konzeptfabrik.vercel.app';

	export let authorName = 'Alex';
	export let showFeedbackButton = true;
	export let showLogoImage = true;
	export let feedbackButtonText = 'Send My Feedback';
	export let authorImage = `${baseUrl}/airbnb-review-user.jpeg`;
	export let logoImage = `${baseUrl}/airbnb-logo.png`;
	export let reviewText = `“Zeno was a great guest! Easy communication, the apartment was left
	  in great condition, very polite, and respectful of all house rules.
	  He’s welcome back anytime and would easily recommend him to any
	  host!”`;
	export let bottomAddress = "Airbnb, Inc., 888 Brannan St, San Francisco, CA 94103";

	const previewText = `Read ${authorName}'s review`;

	const fontFamily =
		'-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen-Sans,Ubuntu,Cantarell,"Helvetica Neue",sans-serif';

	const main = {
		backgroundColor: '#ffffff'
	};

	const container = {
		margin: '0 auto',
		padding: '20px 0 48px',
		width: '580px'
	};

	const userImage = {
		margin: '0 auto',
		marginBottom: '16px',
		borderRadius: '50%'
	};

	const heading = {
		fontFamily,
		fontSize: '32px',
		lineHeight: '1.3',
		fontWeight: '700',
		color: '#484848'
	};

	const paragraph = {
		fontFamily,
		fontSize: '18px',
		lineHeight: '1.4',
		color: '#484848'
	};

	const review = {
		...paragraph,
		padding: '24px',
		backgroundColor: '#f2f3f3',
		borderRadius: '4px'
	};

	const button = {
		fontFamily,
		backgroundColor: '#ff5a5f',
		borderRadius: '3px',
		color: '#fff',
		fontSize: '18px',
		textDecoration: 'none',
		textAlign: 'center' as const,
		display: 'block',
		width: '100%'
	};

	const link = {
		...paragraph,
		color: '#ff5a5f',
		display: 'block'
	};

	const reportLink = {
		fontFamily,
		fontSize: '14px',
		color: '#9ca299',
		textDecoration: 'underline'
	};

	const hr = {
		borderColor: '#cccccc',
		margin: '20px 0'
	};

	const footer = {
		fontFamily,
		color: '#9ca299',
		fontSize: '14px',
		marginBottom: '10px'
	};

</script>

<Html>
	<Head />
	<Preview preview={previewText} />
	<Section style={main}>
		<Container style={container}>
            {#if showLogoImage}
			    <Img src={logoImage} width="96" height="30" alt="Airbnb" />
            {/if}
			<Section>
				<Img src={authorImage} width="96" height="96" alt={authorName} style={userImage} />
			</Section>
			<Heading style={heading}>Here's what {authorName} wrote</Heading>
			<Text style={review}>{reviewText}</Text>
			<Text style={paragraph}>
				Now that the review period is over, we’ve posted {authorName}’s review to your Airbnb
				profile.
			</Text>
			<Text style={paragraph}>
				While it’s too late to write a review of your own, you can send your feedback to {authorName}
				using your Airbnb message thread.
			</Text>
			<Section style={{ padding: '16px 0 20px' }}>
                {#if showFeedbackButton}
				    <Button pY={19} style={button} href="https://airbnb.com/" >{feedbackButtonText}</Button>
                {/if}
			</Section>
			<Hr style={hr} />
			<Text style={{ ...paragraph, fontWeight: '700' }}>Common questions</Text>
			<Text>
				<Link href="https://airbnb.com/help/article/13" style={link}>How do reviews work?</Link>
			</Text>
			<Text>
				<Link href="https://airbnb.com/help/article/1257" style={link}>
					How do star ratings work?
				</Link>
			</Text>
			<Text>
				<Link href="https://airbnb.com/help/article/995" style={link}>
					Can I leave a review after 14 days?
				</Link>
			</Text>
			<Hr style={hr} />
			<Text style={footer}>{bottomAddress}</Text>
			<Link href="https://airbnb.com" style={reportLink}>Report unsafe behavior</Link>
		</Container>
	</Section>
</Html>
```

### 4. Create a Novu Workflow

Next, create a Novu workflow with an email step. This code-first notification workflow approach makes it easy for product teams to modify notification content.

```jsx theme={null}
// src/lib/novu/workflows.ts

import { Client, workflow } from '@novu/framework';
import { render } from 'svelte-email';
import AirbnbReview from '$lib/emails/airbnb-review.svelte';

export const client = new Client({
  
  /**
   * The Novu API key is needed for when you
   * need to sync to Novu Cloud
   */
  apiKey: process.env.NOVU_API_KEY,
  /**
   * Disable this flag only during local development
   * For production this should be true
   */
  strictAuthentication: process.env.NODE_ENV !== "development"
});

export const svelteWorkflow = workflow('airbnb-review', async ({ step, payload }) => {
    await step.email(
        'send-email',
        async (inputs) => {
            const html = render({
                template: AirbnbReview,
                props: {
                    authorName: inputs.authorName,
                    showFeedbackButton: inputs.showFeedbackButton,
                    showLogoImage: inputs.showLogoImage,
                    feedbackButtonText: inputs.feedbackButtonText,
                    bottomAddress: inputs.bottomAddress,
                    authorImage: inputs.authorImage,
                    logoImage: inputs.logoImage
                },
            });
            return {
                subject: `Here's Your Host Feedback`,
                body: html,
            }
        }, {
            inputSchema: {
                type: "object",
                properties: {
                  showFeedbackButton: { type: "boolean", default: true },
                  showLogoImage: { type: "boolean", default: true },
                  authorName: { type: "string", default: "Alex" },
                  feedbackButtonText: { type: "string", default: "Send My Feedback" },
                  authorImage: {
                    type: "string",
                    default: "https://react-email-demo-bdj5iju9r-resend.vercel.app/static/vercel-user.png",
                    format: "uri",
                  },
                  logoImage: {
                    type: "string",
                    default: "https://svelte-email-rjaapma15-konzeptfabrik.vercel.app/airbnb-logo.png",
                    format: "uri",
                  },
                  bottomAddress: {
                    type: "string",
                    default: "Airbnb, Inc., 888 Brannan St, San Francisco, CA 94103",
                  },
                },
            },
        });
    }
);
```

### 5. Preview Email Workflow & Sync to Novu Cloud

Open Dev Studio to preview and make changes to the email workflow as needed via the command below:

```jsx theme={null}
npx novu-labs@latest echo
```

1. Run the Studio

<Frame>
  <img />
</Frame>

**Note:** Use the port on which your Svelte app is running for the Bridge endpoint so that the Novu Dev Studio can connect to your API route.

2. Check out the email workflow and test

<Frame>
  <img />
</Frame>

3. Deploy to Novu Cloud when you're done.

On the top right of the Novu Dev Studio, you can sync to Novu Cloud when you're done working locally.

**Note:** You'll need to create a local tunnel that the Novu Cloud environment can reach for local experimentation purposes. Ngrok is a good tunnel.

### 6. Send a Notification

Trigger a notification using the recently deployed workflow either via your [Novu Cloud dashboard](https://web.novu.co) or [code](/quickstarts/react#trigger-a-notification).

Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows.


# How to send OTP verification email notifications with React-email
Source: https://v0.x-docs.novu.co/guides/framework-guides/otp

Learn how to send OTP verification email notifications with React-email in your NextJS app

## Introduction

In this guide, you’ll learn how to send OTP verification email notifications using the React-email package. Follow these steps:

## Getting started

Integrating Novu’s code-first workflow with React.Email for your Next.js application can be done in a few steps:

1. Create a NextJS app and wait for the installation:

```bash theme={null}
npx create-novu-app@latest --api-key=<YOUR_API_KEY>

// The command will ask you if you want to include react-email into your new project.
```

2. Once this installation is complete, simply `cd` into the directory and start your app using the `npm run dev` command.

## Using a code-first workflow

1. Write an email template - To write an email template, you can look over some of the examples in the [React Email](https://react.email/examples) documentation to get inspiration. In our case, this is the template:

```ts theme={null}
import {
    Body,
    Button,
    Container,
    Head,
    Heading,
    Hr,
    Html,
    Img,
    Link,
    Preview,
    Section,
    Text,
    render
} from "@react-email/components";
import * as React from "react";

interface LinearLoginCodeEmailProps {
    validationCode?: string;
    showJoinButton?: boolean;
    buttonText?: string;
    inviteLink?: string;
    logoURL?: string;
    inviteFromLocation?: string;
    inviteFromIp?: string;
    supportEmail?: string;
}

export const LinearLoginCodeEmail = ({
    validationCode,
    showJoinButton,
    buttonText,
    inviteLink,
    logoURL,
    inviteFromIp,
    inviteFromLocation,
    supportEmail
}: LinearLoginCodeEmailProps) => (
    <Html>
        <Head />
        <Preview>Your login code for Linear</Preview>
        <Body style={main}>
            <Container style={container}>
                <Img
                    src={`${logoURL}`}
                    width="42"
                    height="42"
                    alt="Linear"
                    style={logo}
                />
                <Heading style={secondary}>
                    Your login code for Linear
                </Heading>
                <Section style={buttonContainer}>
                    {showJoinButton && (
                        <Section className="text-center mt-[32px] mb-[32px]">
                            <Button
                                style={button}
                                href={inviteLink}
                            >
                                {buttonText}
                            </Button>
                        </Section>
                    )}
                </Section>
                <Text style={paragraph}>
                    This link and code will only be valid for the next 5 minutes. If the
                    link does not work, you can use the login verification code directly:
                </Text>
                <Section style={codeContainer}>
                    <Text style={code}>{validationCode}110658</Text>
                </Section>
                <Hr style={hr} />
                <Text style={paragraphSupport}>Not expecting this email?</Text>
                <Text style={paragraphSupport}>
                    This invite was
                    sent from <span style={paragraphSupportText}>{inviteFromIp}</span>{" "}
                    located in{" "}
                    <span style={paragraphSupportText}>{inviteFromLocation}</span>.
                </Text>
                <Text style={paragraphSupport}>
                    Please contact{" "}
                    <Link href="mailto:suport@linear.com" style={link}>
                        {supportEmail}
                    </Link>{" "}
                    if you did not request this code.
                </Text>
            </Container>
        </Body>
    </Html>
);

LinearLoginCodeEmail.PreviewProps = {
    validationCode: "tt226-5398x",
} as LinearLoginCodeEmailProps;

export default LinearLoginCodeEmail;

const logo = {
    borderRadius: 21,
    width: 42,
    height: 42,
};

const main = {
    backgroundColor: "#ffffff",
    fontFamily:
        '-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen-Sans,Ubuntu,Cantarell,"Helvetica Neue",sans-serif',
};

const container = {
    margin: "0 auto",
    padding: "20px 0 48px",
    maxWidth: "560px",
};

const secondary = {
    color: "#000",
    display: "inline-block",
    fontFamily: "HelveticaNeue-Medium,Helvetica,Arial,sans-serif",
    fontSize: "20px",
    fontWeight: 500,
    lineHeight: "24px",
    marginBottom: "0",
    marginTop: "2rem",
    textAlign: "center" as const,
};

const paragraphSupportText = {
    fontSize: "15px",
    fontWeight: "700",
};

const paragraph = {
    margin: "0 0 15px",
    fontSize: "15px",
    lineHeight: "1.4",
    color: "#3c4149",
};

const buttonContainer = {
    padding: "27px 0 27px",
};

const button = {
    backgroundColor: "#5e6ad2",
    borderRadius: "3px",
    fontWeight: "600",
    color: "#fff",
    fontSize: "15px",
    textDecoration: "none",
    textAlign: "center" as const,
    display: "block",
    padding: "11px 23px",
};

const hr = {
    borderColor: "#dfe1e4",
    margin: "42px 0 26px",
};

const code = {
    color: "#000",
    display: "inline-block",
    fontFamily: "HelveticaNeue-Bold",
    fontSize: "16px",
    fontWeight: 700,
    letterSpacing: "6px",
    lineHeight: "40px",
    paddingBottom: "8px",
    paddingTop: "8px",
    margin: "0 auto",
    width: "100%",
    textAlign: "center" as const,
};

const paragraphSupport = {
    color: "#444",
    fontSize: "15px",
    fontFamily: "HelveticaNeue,Helvetica,Arial,sans-serif",
    letterSpacing: "0",
    lineHeight: "23px",
    padding: "0 40px",
    margin: "0",
    textAlign: "center" as const,
};

const link = {
    color: "#444",
    textDecoration: "underline",
};

const codeContainer = {
    background: "rgba(0,0,0,.05)",
    borderRadius: "4px",
    margin: "16px auto 14px",
    verticalAlign: "middle",
    width: "280px",
};

export function renderOTPEmail(payload: any) {
    return render(<LinearLoginCodeEmail {...payload} />);
}
```

2. Launch Dev Studio - Novu’s code-first approach lets you see how the template would look when rendered, right when defining it, using the Dev Studio. To launch the dev studio locally you can run `npx novu-labs@latest echo`. The Dev Studio will be started by default on port 2022, and accessible via: [http://localhost:2022](http://localhost:2022)

<Frame>
  <img />
</Frame>

3. Define a workflow that uses that template to send notifications - In this step, we need to define a workflow that uses the template we wrote above to render the email notification:

```ts theme={null}
import { Client, workflow } from "@novu/framework";
import { renderOTPEmail } from "./otp";

export const client = new Client({
  apiKey: process.env.NOVU_API_KEY,
  /**
   * Disable this flag only during local development
   */
  strictAuthentication: process.env.NODE_ENV !== "development",
});

export const otpFlow = workflow('otp-flow', async ({ step, payload }) => {
  // Send a welcome email
  await step.email('send-email', async (inputs) => {
    return {
      subject: `Here's your verification code, Sumit!`,
      body: renderOTPEmail(inputs, payload),
    };
  }, {
    inputSchema: {
      type: "object",
      properties: {
        showJoinButton: { type: "boolean", default: true },
        buttonText: { type: "string", default: "Login to Linear" },
        logoURL: {
          type: "string",
          default: "https://react-email-demo-7qy8spwep-resend.vercel.app/static/linear-logo.png",
          format: "uri",
        },
        supportEmail: { type: "string", default: "support@linear.co" },
        validationCode: { type: "string", default: "tt226-5398x" },
        inviteLink: {
          type: "string",
          default: "https://linear.app",
          format: "uri",
        },
        inviteFromIp: { type: "string", default: "204.13.186.218" },
        inviteFromLocation: {
          type: "string",
          default: "São Paulo, Brazil",
        },
      },
    },
  });
  // JSON Schema for validation and type-safety. Zod, and others coming soon.
}, { payloadSchema: { properties: { text: { type: 'string' } } } });
```

4. Triggering the workflow - Lastly, we need to trigger the workflow we created above. Here’s how to trigger it:

```ts theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

export async function POST(request: Request) {
  const res = await request.json();

  await novu.trigger('otp-flow', {
    to: {
      subscriberId: 'new-user',
    },
    payload: {
      email: res.email,
      username: res.username,
    },
  });

  console.log('triggered')
  return Response.json({ success: true });
}
```

When we trigger this workflow, here’s the email received on the client-side:

<Frame>
  <img />
</Frame>

That’s it!

That’s how you create and use an OTP workflow. You can check out [our docs](https://docs.novu.co/guides/framework-guides/framework-react-email) for a hands on guide with more in-depth instructions.

Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows.

Don’t forget to share your workflows with us and as always, hit us up on Discord with any questions you might have!


# Empowering Product Teams to Manage Notification Workflows
Source: https://v0.x-docs.novu.co/guides/framework-guides/product

Enabling product teams to independently manage and optimize notification workflows for improved efficiency and user experience

# Introduction

Novu’s code-first workflow empowers product teams to manage notification for end-users independently once the engineering teams have built and delivered the notification platform for the product.

Let’s see how product teams can leverage it:

1. **Engineering Team sets things up:** Engineering teams integrate Novu’s code-first workflows into their application. This involves setting up the structure of notification workflows in the codebase, defining events, steps, inputs, payload, etc. These workflows are functions that execute business logic and need to be set only once.
2. **Empowering Non-Technical Teams:** Once the foundational workflows are established, product teams can take over! Code-first workflows allow non-technical users to modify workflows safely without breaking critical integrations. Through an exposed Inputs interface, product teams can adjust notification content and behaviour, tailoring the user experience without needing to dive into the code at all. This helps both teams win - product teams are empowered to manage and optimize notifications independently, creating a dynamic and user-centric notification system without constant reliance on engineering teams.
3. **Insights and Optimization**: Further, with Novu’s Web Dashboard, Product teams gain valuable insights into last-mile delivery from the activity monitor. This enables them to refine notification strategies and optimize for better user satisfaction.

This collaborative approach between the Engineering and Product teams allows both teams to focus on their strengths, resulting in a more efficient and effective notification strategy, without constant interruptions in each other’s flow.

## Customising the workflow

To demonstrate the customizability, we’ll assume that the Engineering team has successfully delivered the basic setup as outlined in [one of our guides.](https://docs.novu.co/guides/framework-guides/framework-react-email)

1. To start things off, you only need to visit the workflow section in our [Web Dashboard](https://web.novu.co/).

<Frame>
  <img />
</Frame>

* You’ll see the blue lightning bolt icon right next to the workflow name symbolising that it is a code-first workflow.
* Now, simply click on the workflow to open it and make your desired changes.
* The green `Sync` indicator on the top right corner means that your app is successfully connected with Novu.

2. Once you open a workflow, you’ll see all the steps of the workflow:

<Frame>
  <img />
</Frame>

3. Simply, select a node to see the rendered view. This is what will get sent to the end user.

<Frame>
  <img />
</Frame>

4. To start making changes, simply click on either of the two buttons highlighted below:

<Frame>
  <img />
</Frame>

5. Once you click on it, you’ll be taken to the edit view where you’ll see real-time preview of the workflow. You can make changes to the step inputs on the right-hand side and the rendered view will update in real-time to reflect those changes

<Frame>
  <img />
</Frame>

6. Let's take a look at what payload and step inputs are:
7. In almost all the scenarios, you’ll be tweaking and modifying step inputs and the workflow editor makes it blazing fast and effortlessly simple. Simply change the text of the respective field or button or toggle any button on or off till the rendered view becomes what you want your end users to receive. Here’s how you can tweak it:

<Frame>
  <img />
</Frame>

## Conclusion

The collaboration resulting from Novu’s code-first workflow increases agility, enabling rapid iterations and quick adjustments based on user feedback. It fosters effective collaboration between product and engineering teams, resulting in a more efficient workflow and improved user notifications.


# How to use Headless Notification Center
Source: https://v0.x-docs.novu.co/guides/headless-notification-center-guide

Use the headless version of the notification center

## Introduction

In this guide, you'll learn about how to use the headless version of our notification center. The headless version is useful for scenarios in which a lightweight solution for integrating notification functionality into a web app that is completely unstyled (so that you can style it as per your wish) is required.

<br />

You can find the entire code ( front-end as well as back-end ) of this app [here.](https://github.com/novuhq/novu-headless-demo-app)

## What is the headless notification center

The headless version of Novu's notification library package provides users with a lightweight solution for integrating notification functionality into their web applications.

<br />

With just the essential API methods, users can easily incorporate our notification system into any framework or vanilla JavaScript project, without being constrained by our default UI or dependencies.

This gives the users of the headless notification center greater flexibility and control over what the end-users of a product see and experience.

## How to use the headless notification center

To get started with this you need:

1. A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-guides-headless) if you don’t have one yet.
2. A working dev environment in the framework of your choice (or vanilla JS). Here, we'll use a React environment

## Workflow set up in Novu

Once, you have signed up for Novu and have a dev environment, follow the steps below:

1. Head over to the Novu Dashboard.
2. Click `Workflows` on the left sidebar of your Novu dashboard.
3. Click the `Create Workflow` button on the top right:

<Frame>
  <img />
</Frame>

Once you click the `create workflow` button, you’ll see a dropdown. Select `blank workflow` from the dropdown:

<Frame>
  <img />
</Frame>

You’ll now be taken to the workflow editor:

<Frame>
  <img />
</Frame>

Once here, you can add the channels you want to use for sending notifications and configure them. For this guide, we’ll use the `In-App` channel.

<Frame>
  <img />
</Frame>

The `In-app` node allows you to further customize the notifications that will get sent, as per your need. In our case, it is a simple `description`, which will contain the text that will be entered from the front end. Here's the `in-app` node for your reference:

<Frame>
  <img />
</Frame>

Here's a brief overview of all the options:

* **1-Preview**: This shows you a glimpse of what each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.

Once you’re done configuring this to your liking, click on the `update` button on the top right. It'll automatically create a trigger code that you can use in your app. To get it, click on the `get snippet` button on the top right and copy it:

<Frame>
  <img />
</Frame>

<br />

Let's now see how to add it to our app!

## Pre-requisites:

To be able to use the headless notification center, you'll first need the following:

1. `applicationIdentifier`: You can find this from the `settings` menu in the [Novu web dashboard.](https://web.novu.co/settings?utm_campaign=docs-guides-headless)
2. `subscriberID`: In most real-world apps, you'll get this from a database. It is used to uniquely identify the entity to whom a notification will be delivered. In our case, we're assuming the `subscriberID` to be `12345`.

## Setting up the back end:

For our demo app, we're setting up the back end as follows:

1. Install the Novu package. Open your terminal and run the following command:

```bash theme={null}
npm install @novu/node
```

Once installed, you can import Novu into your app and initialize it using your Novu account credentials. This step establishes a connection between your app and the Novu notification service.

```bash theme={null}
import { Novu } from '@novu/node';
const novu = new Novu('<NOVU_API_KEY>');
```

<Note>
  Replace the `<NOVU_API_KEY>` value with the authentic key from the API Key section of your [Novu Dashboard.](http://web.novu.co/?utm_campaign=docs-guides-headless)
</Note>

<Note>
  🔑 Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

Using the above info, we'll write a function that will help us interact with Novu's notification system:

```javascript theme={null}
import { Novu } from '@novu/node';

export const notification = async (description) => {
    const novu = new Novu("<NOVU_API_KEY>");
    await novu.subscribers.identify(process.env.SUSBSCRIBER_ID, {
        firstName: 'newSubForHeadless',
    });

// code snippet copied when creating the workflow
    await novu.trigger('headless-demo', {
        to: {
            subscriberId: process.env.SUSBSCRIBER_ID
        },
        payload: {
            description: description
        }
    });

}
```

After this, we'll set up a simple controller function for handling notifications:

```javascript theme={null}
import { notification } from "../novu/novu.js";

export const notifController = async (req,res) => {
    const{description} = req.body;
    try {
        await notification(description)
        res.status(201).json({message:"Subscriber created successfully"});
    } catch (error) {
        console.log("notifController error:",error);
        res.status(500).json({message: error.message})
    }
}
```

And finally, we'll need to establish routes that we'll hit from the front end:

```javascript theme={null}
import express from "express";
import { notifController } from "../controller/notif.js";

const router = express.Router();

router.post("/create-sub",notifController);

export default router;
```

Now, we'll move to the front end because that's where all the magic happens!

## Setting up the front end:

In the front end, install the headless package:

```bash theme={null}
npm install @novu/headless
```

Then, import it and initialize the headless service:

```javascript theme={null}
import { HeadlessService, FetchResult, ISession } from '@novu/headless';

 useEffect(() => {

        const headlessService = new HeadlessService({
            applicationIdentifier: 'SWMw97ec1ZNA',
            subscriberId: '12345',
        });

        headlessService.initializeSession({
            listener: (res) => {
            },
            onSuccess: (session) => {
                headlessServiceRef.current = headlessService;
                fetchNotifications();
            },
            onError: (error) => {
                console.log("headlessSice error:", error);
            },
        })

    }, [fetchNotifications])
```

We've added the `fetchNotifications` function inside a useEffect because we want the effect to run whenever the `fetchNotifications` executes. Here's the `fetchNotifications` function for reference:

```javascript theme={null}
const fetchNotifications = useCallback(() => {
        const headlessService = headlessServiceRef.current;
        if (headlessService) {
            headlessService.fetchNotifications({
                listener: ({ data, error, isError, isFetching, isLoading, status }) => {
                    // Handle the state of the fetching process and errors here.
                },
                onSuccess: (response) => {

                    // Handle the fetched notifications here.
                    setNotifications(response.data); // Store notifications in the state
                },
                page: pageNum, // page number to be fetched
            });
        }
    }, [pageNum])
```

Here, we've memoized the `fetchNotifications` to optimize performance and passed `pageNum` in a dependency array so that it reruns when the page number changes.

<br />

You can refer to the entire context [here](https://github.com/novuhq/novu-headless-demo-app/blob/main/frontend/src/context/NotificationContext.js) for a better understanding.

We've also used several methods related to the Headless Notification Center package. You can find the complete list [here.](/notification-center/client/headless/api-reference)

The methods that we've used in our app are `markNotificationsAsRead`, `deleteNotification`, and `markAllMessagesAsRead`. They are as follows:

```javascript theme={null}

    const markNotificationsAsRead = (messageIds) => {
        if (!Array.isArray(messageIds)) {
            messageIds = [messageIds];
        }

        const headlessService = headlessServiceRef.current;

        if (headlessService) {
            headlessService.markNotificationsAsRead({
                messageId: messageIds,
                listener: (result) => {
                },
                onError: (error) => {
                    console.error('Error marking notifications as read:', error);
                },
            });
        }

    };


const deleteNotification = (messageId) => {
        const headlessService = headlessServiceRef.current;
        if (headlessService) {
            headlessService.removeNotification({
                messageId: messageId,
                listener: function (result) {
                },
                onSuccess: function (message) {
                },
                onError: function (error) {
                    console.error(error);
                },
                messageIds: 'messageOne',
            });

        }
    }

    const markAllMessagesAsRead = (feedId) => {
        const headlessService = headlessServiceRef.current;

        headlessService.markAllMessagesAsRead({
            listener: (result) => {
                console.log(result);
                // Handle the result of marking all messages as read
                // You can update the state or perform other actions here
            },
            onError: (error) => {
                console.error('Error marking all messages as read:', error);
                // Implement error handling if needed
            },
            feedId: feedId, // Pass the feed ID here, it can be an array or a single ID
        });
    };
```

<Note>
  You can view the entire API reference [here](/notification-center/client/headless/api-reference) and pick up the methods that you'd like to use for your specific requirements.
</Note>

### Coding the UI up:

On the UI front, we have a simple form with a submit handler function and a couple of components:

```javascript theme={null}
const Body = () => {

    const [description, setDescription] = useState('');
    const { active, setActive } = useNotification();
    const onSubmitHandler = async e => {
        e.preventDefault()
        await axios.post('https://headless-backend-qx89.onrender.com/api/v1/create-sub', { description })

        setDescription('')
        setActive(true)
    }
    const onChangeHandler = e => {
        setDescription(e.target.value);
    }
    return (
        <div className='body-container'>
            <p>Enter notification text</p>
            <form onSubmit={onSubmitHandler} className="input-form">
                <input className="input" value={description} onChange={onChangeHandler} placeholder="Enter notification text" />
                <button className="form-btn">Send</button>
            </form>
        </div>
    )
}
```

The first component is the `appBar` component which includes a bell icon, which can show notifications in a modal when clicked. The modal is displayed when showModal is true, and the modal can be closed by clicking outside of it. The component interacts with the notification-related functionalities provided by the useNotification hook:

```javascript theme={null}
const AppBar = () => {
    const [showModal, setShowModal] = useState(false);
    const modalRef = useRef(null);

    const { fetchNotifications, setActive, active } = useNotification();

    const handleShowNotification = async (e) => {
        e.stopPropagation();
        setShowModal((prev) => !prev);
        await fetchNotifications();
        setActive(false);
    };
    const handleCloseModal = () => {
        setShowModal(false);
    }
    useEffect(() => {
        const handleDocumentClick = e => {
            if (modalRef.current && !modalRef.current.contains(e.target)) {
                handleCloseModal();
            }
        }
        if (showModal) {
            document.addEventListener('click', handleDocumentClick);
        }
        return () => {
            document.removeEventListener('click', handleDocumentClick)
        }
    }, [showModal])

    return (
        <div>
            <div className='app-bar-container'>
                <span onClick={handleShowNotification} className='bell-icon'>
                    <BsBell />
                    <div className={`${active ? `active` : ''}`}>
                        <div className='dot'></div>
                    </div>
                </span>
            </div>
            <div className={`modal-div ${showModal ? 'modal-show' : ''}`} ref={modalRef}>
                {showModal && (<NotificationModal />)}
            </div>
        </div>
    );
};

export default AppBar;
```

And the second component is the `NotificationModal` which is what gets displayed when the user clicks on the bell icon.

<Note>
  The beauty of using the headless version of the notification center is that you can customise exactly how it looks and which functionalities you need in it.
</Note>

Our `NotificationModal` component is as follows:

```javascript theme={null}
const NotificationModal = () => {

    const { notifications, markNotificationsAsRead, markAllMessagesAsRead, deleteNotification, setPageNum, pageNum, fetchNotifications } = useNotification();

    const handleNotificationRead = (notificationId) => {
        markNotificationsAsRead(notificationId);
    }

    const handleNotificationDelete = (notificationId) => {
        let newClass = document.getElementById(`${notificationId}`);
        newClass.style.display = 'none';
        deleteNotification(notificationId);
    }

    const handleMarkAllAsRead = () => {
        markAllMessagesAsRead();
    }
    const onPrvHandler = () => {
        setPageNum((prv) => prv - 1)

    }
    const onNxtHandler = () => {
        setPageNum((prv) => prv + 1)

    }


    useEffect(() => {
        fetchNotifications();
    }, [pageNum, fetchNotifications])
    return (
        <div className='bell-container'>
            <div className='heading'>
                <div className='title'>
                    <h2>
                        Notifications
                    </h2>
                </div>
                <div className='control-btn'>
                    <button className='modal-btn all-read title-btn' onClick={handleMarkAllAsRead}>Mark all as read</button>
                    <button className={` ${pageNum === 0 ? '' : 'modal-btn title-btn'}`} onClick={onPrvHandler} disabled={pageNum === 0 ? true : false}>Previous</button>
                    <button className={` ${notifications.length < 10 ? '' : 'modal-btn title-btn'}`} onClick={onNxtHandler} disabled={notifications.length < 10 ? true : false}>Next</button>
                </div>
            </div>
            <div>
                {notifications.map(not => (
                    <div key={not.id} className={`individual-notif`} id={`${not.id}`}>
                        <>
                            <span className={`bell-notif ${not.read ? 'read' : ''}`}>
                                {not?.payload?.description}
                            </span>
                            <div className='btn-container'>
                                {!not?.read && (
                                    <button onClick={() => handleNotificationRead(not?.id)} className='read-btn classic-btn'>Read</button>
                                )}
                                <button onClick={() => handleNotificationDelete(not?.id)} className='delete-btn classic-btn'>Delete</button>
                            </div>
                        </>
                    </div>
                ))
                }
            </div>
        </div>
    )
}
```

Finally, we've used some css to style the app to our liking. You can see that [here.](https://github.com/novuhq/novu-headless-demo-app/tree/main/frontend/src/styles).

## Conclusion

If you've followed everything till here, you'll end up with an app like the following:

<Frame>
  <img />
</Frame>

Again, don't forget that you can view the entire code [here](https://github.com/novuhq/novu-headless-demo-app/tree/main) and if you've any questions, either related to this headless app or something else, feel free to ping use [here.](https://discord.gg/novu)
Also, we've several demo apps for you to check out [here.](/demos/introduction)
Thanks for reading!


# How To Integrate Segment With Novu
Source: https://v0.x-docs.novu.co/guides/how-to-integrate-segment-with-novu



[Segment](https://segment.com/) is a customer data platform that helps businesses collect, manage, and analyze customer data from multiple sources. It streamlines data integration, ensures data quality, and aids in compliance with regulations. Segment's tools enable better understanding of customer behavior and facilitate personalized customer experiences. It's useful for marketing, analytics, and product teams in diverse industries.

If this is your first time working with the tool, consider consulting the 'Get Started' guide in [Segment's official documentation](https://segment.com/docs/getting-started/).

## Examples Use Case

**Enhancing Customer Engagement and Conversion Rates**

<Steps>
  <Step title="Data Integration with Segment">
    * The e-commerce platform uses Segment to collect and unify customer data from various sources like website visits, purchase history, and customer interactions.
    * Segment helps in creating a unified customer profile by consolidating data from different touchpoints – mobile app usage, website browsing patterns, and previous purchase behavior.

    <iframe title="YouTube video player" />
  </Step>

  <Step title="Behavioral Analysis and Segmentation">
    * The data collected is analyzed to understand customer preferences, buying patterns, and engagement levels.
    * Customers are segmented into different groups based on their behavior, interests, and purchase history. For instance, one segment might include frequent shoppers, while another might focus on those who browse but rarely purchase.

    <iframe title="YouTube video player" />
  </Step>

  <Step title="Personalized Notification with Novu">
    * Novu is used to craft and send personalized notifications to these segmented groups.
    * For frequent shoppers, notifications about new arrivals or exclusive deals might be sent. For those who browse but rarely buy, notifications could include special discount codes or reminders about items left in the cart.

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Trigger-Based Notifications">
    * Notifications can also be triggered based on specific customer actions. For example, if a customer views a product but doesn't make a purchase, they might receive a notification later highlighting a special offer on that product.

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Feedback Loop for Continuous Improvement">
    * Customer responses to these notifications are fed back into Segment. This data is used to refine customer profiles and segmentation strategies continuously.
    * The effectiveness of different types of notifications is analyzed to optimize future communication.
  </Step>
</Steps>

**Outcome:**

* Enhanced customer engagement through personalized and timely notifications.

* Improved conversion rates by targeting customers with relevant offers based on their behavior and preferences.

* Greater customer loyalty due to a tailored shopping experience.

## Setting Novu as a Destination

As of <Tooltip>today</Tooltip> Segment doesn’t have a native Novu Destination integration **yet** .

We will be using [Destination Functions](https://segment.com/docs/connections/functions/destination-functions/). Destination functions allow you to transform and annotate your Segment events and send them to any external tool or API without worrying about setting up or maintaining any infrastructure.

### Create a destination function

* From your workspace, go to `Connections > Catalog` and click the `Functions` tab.
* Click `New Function`.
* Select `Destination` as the function type and click `Build`.
* After you click `Build`, a code editor appears. Use the editor to write the code for your function, configure settings, and test the function’s behavior.

<Tip>Want to see some example functions? Check out the templates available in the Functions UI, or in the open-source Segment Functions Library.</Tip>

### Code the destination function

Segment invokes a separate part of the function (called a “handler”) for each event type that you send to your destination function.

<Note> Your function isn’t invoked for an event if you’ve configured a destination filter, and the event doesn’t pass the filter. </Note>

The default source code template includes handlers for all event types. You don’t need to implement all of them - just use the ones you need, and skip the ones you don’t.

Destination functions can define handlers for each message type in the Segment spec:

* onIdentify
* onTrack
* onPage
* onScreen
* onGroup
* onAlias
* onDelete
* onBatch

Each of the functions above accepts two arguments:

`event` - Segment event object, where fields and values depend on the event type.
For example, in “Identify” events, Segment formats the object to match the Identify spec.

`settings` - Set of settings for this function.
The example below shows a destination function that listens for “Track” events, and sends some details about them to an external service.

```javascript theme={null}
async function onTrack(event) {
  await fetch('https://example-service.com/api', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      event_name: event.event,
      event_properties: event.properties,
      timestamp: event.timestamp
    })
  })
}
```

To change which event type the handler listens to, you can rename it to the name of the message type.

For example, if you rename this function `onIdentify`, it listens for “Identify” events instead.

<Tip>
  If you you need an example of Novu destination function, you can find it in [here](https://github.com/novuhq/segment-novu-destination-scripts).
  Feel free to submit your function examples as well!
</Tip>

### Sending a payload to Novu

Now let's learn how to send a payload to Novu based on the `onTrack` event function:

To successfully send a payload to Novu, triggering the appropriate [workflow](/getting-started/concepts#workflow) and delivering it to the correct customer, please ensure that you provide the following information:

1. Novu's Workflow Identifier.
2. Subscriber ID (Please ensure that the Subscriber ID is both unique and consistent across all of your databases).
3. Your Novu API Key.
4. [Novu's Event Trigger API Endpoint](https://api.novu.co/events/trigger)

```javascript theme={null}
async function onTrack(event, settings) {
	const eventProperties = event.properties;

	if (!eventProperties.environment) {
		throw new InvalidEventPayload('environment property is required');
	}
	if (!eventProperties.name) {
		throw new InvalidEventPayload('Workflow name property is required');
	}

	console.log('environment:', eventProperties.environment);

	const payload = {
		name: eventProperties.name,
		to: {
			subscriberId: eventProperties.user.subscriberId,
			email: eventProperties.user.email,
			firstName: eventProperties.user.firstName,
			lastName: eventProperties.user.lastName
		},
		payload: { eventProperties }
	};
	const endpoint = settings.novuEndpoint;
	console.log('endpoint:', endpoint);

	const ApiKey = settings.novuApiKey; // Your NOVU API key
	if (eventProperties.environment === settings.environment) {
		let response;
		try {
			response = await fetch(endpoint, {
				method: 'POST',
				headers: {
					Authorization: `ApiKey ${ApiKey}`,
					'Content-Type': 'application/json'
				},
				body: JSON.stringify(payload)
			});
		} catch (error) {
			// Retry on connection error
			throw new RetryError(error.message);
		}
		if (response.status >= 500 || response.status === 429) {
			// Retry on 5xx (server errors) and 429s (rate limits)
			throw new RetryError(`Failed with ${response.status}`);
		}
	}
}
```

#### Create Settings and Secrets

Segment's settings allow you to pass configurable variables to your function, which is the best way to pass sensitive information such as security tokens. For example, you might use settings as placeholders to use information such as an API endpoint and API key.
You can learn more about it [here](https://segment.com/docs/connections/functions/destination-functions/#create-settings-and-secrets).

<Frame>
  <img />
</Frame>

Click `Add Setting` to add your new setting.

<Frame>
  <img />
</Frame>

Now, while configuring the function, Add these three variables to be then used in the code exposed in the settings function param.

<Frame>
  <img />
</Frame>

#### Test the destination function

You can test your code directly from the editor in two ways:

**1. Use sample events for testing**
Click `Use Sample Event` and select the source to use events from.

<Frame>
  <img />
</Frame>

Click `Run` to test your function with the event you selected.

**2. Test using manual input**
You can also manually include your own JSON payload of a Segment event, instead of fetching a sample from one of your workspace sources.

<Frame>
  <img />
</Frame>

**Here is the the event example JSON we will use**

```JSON theme={null}
{
  "type": "track",
  "event": "User Abandoned Cart",
  "properties": {
    "name": "abandoned-cart-recovery-workflow",
    "user": {
      "subscriberId": "63da8ee0c037e013fd790ffd",
      "email": "hi@hi.com",
      "firstName": "John",
      "lastName": "Doe"
    },
    "environment": "development"
  }
}
```

We will now execute the function based on the manual event input we've provided. This function sends a trigger to Novu, prompting to take action and send the user an email to return and the purchase.

<Frame>
  <img />
</Frame>

Whether you chose the first or second option to test your Destination Function, you can also check if the function triggered your workflow and whether it was delivered through Novu's [Activity Feed](https://web.novu.co/activities?utm_campaign=docs-guides-segment).

<Frame>
  <img />
</Frame>

This guide was inspired by the following resources:

* [https://discord.com/channels/895029566685462578/1060308007658987571/1077377322547687475](https://discord.com/channels/895029566685462578/1060308007658987571/1077377322547687475)
* [https://segment.com/docs/getting-started/05-data-to-destinations/](https://segment.com/docs/getting-started/05-data-to-destinations/)
* [https://aviyel.com/post/3381/how-to-integrate-novu-with-segment](https://aviyel.com/post/3381/how-to-integrate-novu-with-segment)


# How to send push notifications in an Android app (react native) with FCM and Novu
Source: https://v0.x-docs.novu.co/guides/novu-fcm-react-native-android

Learn how to send FCM push notifications in a React native Android app using Novu and FCM

## Prerequisites

To complete this tutorial, you will need the following:

* A [Firebase](https://firebase.google.com/) account
* A [Novu](https://web.novu.co/?utm_campaign=docs-gs-guides-fcm-android) account
* An [Expo](https://expo.dev) account

Push notifications are notifications that are sent to a user’s devices whether the user is using the app or not. We’ll be using the Firebase Cloud Messaging (FCM) integration of Novu to send these notifications. You can find the complete code for this project in our [Github repo.](https://github.com/novuhq/fcm-react-native-android)

## Start a React-Native project

We'll use the `create-expo` tool to initialize a new expo app. It creates a new React Native app with the expo package installed. We're naming our app `fcm-novu-rn2` and hence using the following command:

```javascript theme={null}
 npx create-expo-app fcm-novu-rn2
```

<Info>If it asks you to choose a template, choose the 'blank' template.</Info>

Now, go to the project directory and install the `react-native-firebase` package using the following command:

```bash theme={null}
npm install --save @react-native-firebase/app
```

Once this is installed, install the messaging module of Firebase using the following command:

```bash theme={null}
npm i --save @react-native-firebase/messaging
```

## Getting the FCM token

Now, we need to grab the `token key` from FCM. We'll need this to send notifications using FCM. We're using `useEffect` to grab this key as follows:

```jsx theme={null}
// import messaging module
import messaging from '@react-native-firebase/messaging';

// Request permission to send notifications
const authStatus = await messaging().requestPermission();

// Check if permission is granted or provisional
const enabled =
  authStatus === messaging.AuthorizationStatus.AUTHORIZED ||
  authStatus === messaging.AuthorizationStatus.PROVISIONAL;

// If permission is granted or provisional, proceed
if (enabled) {
  // Log the authorization status
  console.log('Authorization status:', authStatus);

  // Retrieve the FCM token for the device
  const token = await messaging().getToken();
  // Log the FCM token
  console.log('FCM Token is:', token);

  // Return a function to unsubscribe from notifications
  return unsubscribe;
} else {
  // If permission is not granted, log the error status
  console.log('Could not grab token...', authStatus);
}

```

## FCM handlers

FCM uses something called a `background handler` to, as the name suggests handle notifications when the app is in the background. So, we'll add it to our app:

```jsx theme={null}
// Background message handler for incoming messages while the app is in bg
messaging().setBackgroundMessageHandler(async (remoteMessage) => {
  // Log a message indicating that a message was handled in the background
  console.log('Message handled in the background!', remoteMessage);
});

```

Similarly, we also need a `foreground handler` to handle notifications when the app is in the foreground. In our case, we're updating a state's value in our handler. Here's our foreground handler:

```jsx theme={null}
// handle incoming messages while the app is in the foreground
const unsubscribe = messaging().onMessage(async (remoteMessage) => {
  // Log a message indicating that the onMessage event is working
  console.log('working!!!!');
  
  // Update state with the received message
  setNotification(remoteMessage);
});
return unsubscribe;
```

## Setting up Expo

In order to load projects from Expo CLI, we need a dev client to be installed in our app. To install it, execute the following command from the root of the project directory:

```bash theme={null}
 npx expo install expo-dev-client
```

Once installed, log into your expo account using the following command:

```bash theme={null}
eas login
```

It'll ask for your username and password and log you in.

Now, we are ready to create our build of the app. Use the following command to create a development build of the app for the Android platform:

```bash theme={null}
eas build --profile development --platform android
```

<Info>If expo asks if you want to automatically create an EAS project for your app, choose yes. Do the same when it asks you if you want to generate a new keystore.</Info>
<Warning>Do not change the Android package name, even if EAS asks you to!</Warning>

## Setting up Firebase

1. Create a Firebase account if you don't already have one. Then, create a new project and all the relevant details.

<Frame>
  <img />
</Frame>

2. Once your project has been created, you'll be greeted with this welcome screen and asked to add Firebase to your app, so let's do that.

<Frame>
  <img />
</Frame>

3. We'll choose the 'Android' option because we're creating an Android app.

<Frame>
  <img />
</Frame>

4. Find the package name from the `app.json` file of the project:

<Frame>
  <img />
</Frame>

5. Add this package name to Firebase:

<Frame>
  <img />
</Frame>

6. Now, we need to add `SHA1` keys from our project to the Firebase app. Run the following command to obtain `SHA1` key. We'll get two `SHA1` keys, one of which we'll add to Firebase right now and the other one, later on.

```bash theme={null}
eas credentials
```

<Info>If it asks you to, choose the 'Android' platform then 'Development' build then 'Keystore' then 'Set up a new keystore' then 'Select Build Credentials' and then 'Create a new build credential configuration'.</Info>

<Frame>
  <img />
</Frame>

7. Now copy the `SHA1` key and add it to Firebase and register the app:

<Frame>
  <img />
</Frame>

8. Click 'next' on all the other options and finally click 'continue to console' as follows:

<Frame>
  <img />
</Frame>

9. Go to 'project settings' and scroll all the way down

<Frame>
  <img />
</Frame>

10. Click on the 'Add fingerprint' button and add the second `SHA1` key here.

<Frame>
  <img />
</Frame>

11. Now, download the Google services file and add it to the project's root directory. We also need to specify its location in the `app.json` file:

<Frame>
  <img />
</Frame>

12. Now we need to upload the Firebase server key to expo. Go to project settings and find it under the 'Cloud Messaging' tab.

<Frame>
  <img />
</Frame>

13. Now, upload that key to expo using the following command:

```bash theme={null}
expo push:android:upload --api-key <your server key here> 
```

14. Rebuild the app using the following command and we're good to go!

```bash theme={null}
eas build --profile development --platform android
```

15. If you have an Android device with you, simply scan and install the app. Otherwise, if you want to run it on an emulator, simply copy the link given alongside the QR code and open it on the emulator and then install the app.

16. Start the server to run the app, using the following command:

```bash theme={null}
npx expo start --dev-client
```

Again, you can either scan the QR code or copy and paste the link.

<Frame>
  <img />
</Frame>

<Warning>Sometimes it doesn't fire up the emulator even when you have it installed. In that case, start the emulator manually and run the server again!</Warning>

## Setting up Novu

We'll need a workflow to trigger notifications to our user's devices. Follow the steps below to create one to ensure we are on the path to making FCM work as expected:

1. Head over to the [Integrations Store](https://web.novu.co/integrations?utm_campaign=docs-guides-fcm-android) on the Novu Web Dashboard and make sure that you've turned on the 'Firebase Cloud Messaging' integration.

<Frame>
  <img />
</Frame>

<Info>If you're doing this for the first time, you'll need to get your service account key from the [Firebase Console](https://console.firebase.google.com/). Read more about it in our [FCM provider docs.](https://docs.novu.co/channels-and-providers/push/fcm)</Info>
2\. Now, we need to create a workflow that we'll trigger from our app to send notifications. Head over to [workflows in the Novu Web Dashboard](https://web.novu.co/workflows?utm_campaign=docs-guides-fcm-android) and click on the 'Add a workflow' button.

<Frame>
  <img />
</Frame>

3. Choose the 'blank workflow' option from the dropdown menu.

<Frame>
  <img />
</Frame>

3. Drag and drop the 'Push' node below the Workflow Trigger node.

<Frame>
  <img />
</Frame>

4. If you hover over the newly added 'Push' node, you'll see an error saying 'Message content and title are missing'.

<Frame>
  <img />
</Frame>

5. We're going to add a title and body for notifications. So, add them and give your workflow a suitable name.

<Frame>
  <img />
</Frame>

6. Now, click on the 'Update' and then the 'get snippet' button to get the trigger code.

<Frame>
  <img />
</Frame>

## Create a subscriber and update credentials

A subscriber is essentially the recipient of the notifications sent through Novu’s system. When you create a subscriber, you’re setting up the necessary information for Novu to send targeted notifications to. You can find more about subscribers in [our docs.](https://docs.novu.co/subscribers/subscribers)
To create a subscriber, we'll use the `identify` method:

```jsx theme={null}
// creating new instance of Novu
const novu = new Novu("<Novu API key>");

// creating subscriber
await novu.subscribers.identify('newSubForRNA', {
    firstName: "RNA"
});
```

Now, we'll add the FCM token that we'd received [earlier](#getting-the-fcm-token) to this subscriber using the `setCredentials` method:

```jsx theme={null}
await novu.subscribers.setCredentials('newSubForRNA', PushProviderIdEnum.FCM, {
    deviceTokens: ['<Enter the FCM token here>'],
});
// notice the use of 'newSubForRNA' here. This identifies the subscriber to which we're adding the FCM token
```

## Sending a push notification using Novu

To send a notification with Novu, we are actually triggering a notification workflow. Here's how to do it using Node:

```jsx theme={null}
novu.trigger('rna-2', {
    to: {
        subscriberId: 'newSubForRNA'
    },
    payload: {},
})
```

When triggered using the trigger code from above, this is the notification received on the device:

<Frame>
  <img />
</Frame>

## Dynamic content

So far, we've sent notifications that have had "hard-coded" content. Now we'll send dynamic data when triggering a notification.

The way to do so is by changing the values of the title and the body to `{{title}}` and `{{body}}` in our workflow.

1. Go to the workflow we'd created earlier and change the values of the title and the body to `{{title}}` and `{{body}}` respectively.

<Frame>
  <img />
</Frame>

2. Simply add these identifiers to the payload by changing the trigger code:

```jsx theme={null}
novu.trigger('rna-2', {
    to: {
        subscriberId: 'newSubForRNA'
    },
    payload: {
        title: payloadTitle,
        body: payloadBody
    },
});
```

<Note>We're extracting `payloadTitle` and `payloadBody` from the request body</Note>
Now, the notification delivered to the subscriber will contain dynamic data as shown below:

<Frame>
  <img />
</Frame>

## Sending images

Up to this point, your notifications have all contained only text. But if you’ve received many notifications, you know that notifications can have rich content, such as images. It’d be great if your notifications showed users a nice image related to their content. Once again, Firebase makes this super simple.

All you need to do is to specify the `URL` of the image in the override as shown below:

```jsx theme={null}
novu.trigger('rna-2', {
    to: {
        subscriberId: 'newSubForRNA'
    },
    payload: {
        title: payloadTitle,
        body: payloadBody
    },
    overrides: {
        fcm: {
            android: {
                notification: {
                    imageUrl: 'URL of the image',
                }
            }
        }
    }
});
```

The following notification is what gets delivered to the subscriber:

<Frame>
  <img />
</Frame>

## Handling data type messages

With FCM, you can send `Notification` and `Data` messages. We have handled sending notification messages. Let’s handle data messages. Data type messages are useful when, in addition to the usual data, you want to send some custom data. Maybe whether a subscriber has purchased the pro plan of our product or not, maybe which tier of usage they have purchased etc. You can do this easily by modifying the override. Here's an example of sending the subscription status using the identifier `subStatus`:

```jsx theme={null}
novu.trigger('rna-2', {
    to: {
        subscriberId: 'newSubForRNA'
    },
    payload: {
        title: payloadTitle,
        body: payloadBody
    },
    overrides: {
        fcm: {
            android: {
                    data: {
                        subStatus: "true"
                    },
            }
        }
    }
});
```

On the user's device, you can extract this out and have it displayed like this:

<Frame>
  <img />
</Frame>

## Priority of a notification

FCM tries to deliver high-priority messages immediately. The priority of a notification can also be altered by changing the overrides, as shown below:

```jsx theme={null}
novu.trigger('rna-2', {
    to: {
        subscriberId: 'newSubForRNA'
    },
    payload: {
        title: payloadTitle,
        body: payloadBody
    },
    overrides: {
        fcm: {
            android: {
                    data: {
                        subStatus: "true"
                    },
                    notification: {
                        priority: 'low'
                    }
            }
        }
    }
});
```

<Frame>
  <img />
</Frame>

## Additional resources

* [Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging)
* [FCM Architectural Overview](https://firebase.google.com/docs/cloud-messaging/fcm-architecture)


# How to send web push notifications with FCM and Novu
Source: https://v0.x-docs.novu.co/guides/novu-fcm-web

Send FCM push notifications in a React app using Novu

## Introduction

In this guide, we'll learn how to send FCM push notifications in a web app using Novu. But before exploring the actual code, let’s understand what a push notification is and how it works.
You can find the [frontend code](https://github.com/novuhq/fcmWebPushFE) as well as [backend code](https://github.com/novuhq/FCMWebPushBE) for the app on Github.

<br />

Push notifications are notifications that are sent to a user's devices whether the user is using the app or not. We'll be using Firebase Cloud Messaging (FCM) integration of Novu to send these notifications. This guide will be broken down into three parts:

1. Setting up Novu.
2. Setting up Firebase.
3. Adding Firebase to the Frontend.
4. Adding Novu to the Backend.

## Setting up Firebase

1. Create a Firebase account if you don't already have one. Then, create a new project and all the relevant details.

<Frame>
  <img />
</Frame>

2. Once your project has been created, you'll be greeted with this welcome screen and asked to add Firebase to your app, so let's do that.

<Frame>
  <img />
</Frame>

3. We'll choose the web option because we're creating a web app.

<Frame>
  <img />
</Frame>

4. Give your app a name and click on the 'Register' button.

<Frame>
  <img />
</Frame>

5. We're done with the Firebase setup! Now, we'll set up Novu and finally proceed to add both (Novu and FCM) to our app.

## Setting up Novu

We'll need a workflow to trigger notifications to our user's devices. Follow the steps below to create one to ensure we are on the path to make FCM work as expected:

1. Head over to the [Integrations Store](https://web.novu.co/integrations?utm_campaign=docs-guides-fcm-web) on the Novu Web Dashboard and make sure that you've turned on the 'Firebase Cloud Messaging' integration.

<Frame>
  <img />
</Frame>

<Info>If you're doing this for the first time, you'll need to get your service account key from the [Firebase Console](https://console.firebase.google.com/). Read more about it in our [FCM provider docs.](https://docs.novu.co/channels-and-providers/push/fcm)</Info>
2\. Now, we need to create a workflow that we'll trigger from our app to send notifications. Head over to [workflows in the Novu Web Dashboard](https://web.novu.co/workflows?utm_campaign=docs-guides-fcm-web) and click on the 'Add a workflow' button.

<Frame>
  <img />
</Frame>

3. Choose the 'blank workflow' option from the dropdown menu.

<Frame>
  <img />
</Frame>

3. Drag and drop the 'Push' node below the Workflow Trigger node.

<Frame>
  <img />
</Frame>

4. If you hover over the newly added 'Push' node, you'll see an error saying 'Message content and title are missing'.

<Frame>
  <img />
</Frame>

5. We're going to use the identifiers `title` and `body` for the title and the content of notifications, so let's add them in the 'Push message title' and the 'Push message content' fields respectively. So, add them and give your workflow a suitable name.

<Frame>
  <img />
</Frame>

6. Now, click on the 'get snippet' button to get the trigger code.

<Frame>
  <img />
</Frame>

## Adding Firebase to the frontend

1. In your project, add Firebase using the following command:

```bash theme={null}
npm install firebase
```

2. Create a new file called `firebase.js` and add the following to it:

```jsx theme={null}
import { initializeApp } from "firebase/app";
import { getMessaging, onMessage } from "firebase/messaging";

//from firebase console
// Your web app's Firebase configuration
const firebaseConfig = {
    apiKey: import.meta.env.VITE_FIREBASE_API_KEY,
    authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN,
    projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID,
    storageBucket: import.meta.env.VITE_FIREBASE_STORAGE_BUCKET,
    messagingSenderId: import.meta.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
    appId: import.meta.env.VITE_FIREBASE_APP_ID,
};

// Initialize Firebase
export const app = initializeApp(firebaseConfig);

// Initialize Firebase Cloud Messaging and get a reference to the service
export const messaging = getMessaging(app);

export const onMessageListener = () =>
    new Promise((resolve) => {
        onMessage(messaging, (payload) => {
            console.log("payload", payload)
            resolve(payload);
        });
    });
```

3. Now, we need to generate tokens using the `getToken` method provided by Firebase. But we want to use this only when the user has allowed notifications on their end. So let's request notification permission from the user and if granted, we'll generate the token. Add this to your root module:

```jsx theme={null}
 async function requestPermission() {
    const permission = await Notification.requestPermission()
    if (permission === 'granted') {
      // get token
      const token = await getToken(messaging, { vapidkey: import.meta.env.VITE_VAPID_KEY })
    } else if (permission === 'denied') {
      alert('Persmission denied!')
    }
  }
  useEffect(() => {
    requestPermission();
  }, [])
```

4. To use the `getToken` method, you need a Voluntary Application Server Identification or `VAPID key`. Go to your Project Settings -> Cloud Messaging -> Generate key pair (under Web Push Certificates):

<Frame>
  <img />
</Frame>

5. In order for Firebase's background listener service to work, you need a service worker. Make sure you've created a service worker file `firebase-messaging-sw.js` and add the following to it:

```jsx theme={null}
importScripts("https://www.gstatic.com/firebasejs/8.10.0/firebase-app.js");
importScripts(
    "https://www.gstatic.com/firebasejs/8.10.0/firebase-messaging.js"
);

const firebaseConfig = {
    apiKey: import.meta.env.VITE_FIREBASE_API_KEY,
    authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN,
    projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID,
    storageBucket: import.meta.env.VITE_FIREBASE_STORAGE_BUCKET,
    messagingSenderId: import.meta.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
    appId: import.meta.env.VITE_FIREBASE_APP_ID,
};

firebase.initializeApp(firebaseConfig);
const messaging = firebase.messaging();
messaging.onBackgroundMessage((payload) => {
    console.log(
        "notif incoming",
        payload
    );
    const notificationTitle = JSON.parse(JSON.parse(payload.notification)).title
    // payload.notification.title;
    const notificationOptions = {
        body: payload.notification.body,
        icon: payload.notification.image,
    };

    self.registration.showNotification(notificationTitle, notificationOptions);
});


```

## Adding Novu to the backend

In your app's backend, add Novu using the following command:

```bash theme={null}
npm install @novu/node
```

Now, create a route that you want to hit when called from the front end. In our app, this is the route:

```jsx theme={null}
import express from "express";
import { createNotif } from '../controller/notif.js'

const router = express.Router();

router.post('/create', createNotif)

export default router;
```

Now, we need a controller function to handle the logic for what is to be sent in the trigger function’s payload. In our case, this is the controller function:

```jsx theme={null}
import { inAppNotification } from "../novu/novu.js";

export const createNotif = async (req, res) => {

    const { title, body } = req.body
    try {
        await inAppNotification(title, body);
        res.status(201).json({ message: 'success', title: title, body: body });
    } catch (error) {
        res.status(409).json({ message: error.message });
    }
}
```

To make it modular, we’ll keep the trigger code in a separate function in a separate file (`novu.js`, in our case) and the trigger function is getting called in the controller function above by the name `createNotif`.

If you’re following the guide, you should already have the trigger function. But before we can add it to our app, we need one key thing - **Subscribers.**

[Subscribers](https://docs.novu.co/subscribers/subscribers) are entities to which the notifications are sent. You can see a list of subscribers in the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-guides-fcm-web) as well.

We'll create a subscriber in our app. Our backend will be written in Node.js, but we also have backend [SDKs in PHP, .NET, Go, Ruby, Python, and Kotlin](/sdks/introduction). The recommended way to create a subscriber in NodeJS is as follows:

```jsx theme={null}
 await novu.subscribers.identify(process.env.NOVU_SUB_ID, {
        firstName: "pushSubscriber"
    });
```

Here, we're creating a subscriber with the `subscriberID` of whatever value the `env` file contains for the identifier `NOVU_SUB_ID`. You can read more about subscribers [in our docs.](/subscribers/subscribers).

Back in our app, before we can now add the trigger function, we need to set device identifiers using the [setCredential method](https://docs.novu.co/channels-and-providers/push/fcm#set-device-token):

```jsx theme={null}
await novu.subscribers.setCredentials(process.env.NOVU_SUB_ID, PushProviderIdEnum.FCM, {
        deviceTokens: [process.env.DEVICE_TOKEN],
    });
```

<Info>You'll need to pass the `subscriberID` and the `deviceTokens` in the `setCredentials` method.</Info>

Finally, we can add the trigger code:

```jsx theme={null}
import { Novu, PushProviderIdEnum } from '@novu/node';

export const inAppNotification = async (title, body) => {

    const novu = new Novu(process.env.NOVU_API_KEY);
    await novu.subscribers.identify(process.env.NOVU_SUB_ID, {
        firstName: "pushSubscriber"
    });

    await novu.subscribers.setCredentials(process.env.NOVU_SUB_ID, PushProviderIdEnum.FCM, {
        deviceTokens: [process.env.DEVICE_TOKEN],
    });

    novu.trigger(process.env.NOVU_WORKFLOW_ID, {
        to: {
            subscriberId: process.env.NOVU_SUB_ID
        },
        payload: {
            title: title,
            body: body
        },
    });
};
```

We're done with the app. You can find the [frontend code](https://github.com/novuhq/fcmWebPushFE) as well as [backend code](https://github.com/novuhq/FCMWebPushBE) for the app on Github.

Congratulations on following the guide up until this point. If you’ve done everything as recommended, you’ll end up with an app that uses Firebase Cloud Messaging to send notifications to your users using Novu.


# How to use Novu to send notifications to a Slack channel
Source: https://v0.x-docs.novu.co/guides/slack-guide

Learn to send Slack notifications swiftly with Novu (manually managed)

# Introduction

In this guide, you'll learn how to use Novu to send notifications directly to a Slack channel. But before coding anything up, we first need to go through a setup process.
The corresponding docs for this guide are available on our [docs](https://docs.novu.co/channels-and-providers/chat/slack).
<Note>The entire code of this app (frontend as well as backend) can be found [here](https://github.com/novuhq/slack-app).</Note>

So let's begin!

# Create a Slack App

Creating a Slack app is fairly simple. Follow these steps to create your app:

1. Go to [Slack's app dashboard](https://api.slack.com/apps) and click on the 'Create new App' button, as shown in the image:

<Frame>
  <img />
</Frame>

2. Choose 'From Scratch' from the following dialog:

<Frame>
  <img />
</Frame>

3. Choose a name for your app and select the Slack workspace in which you want to send notifications:

<Frame>
  <img />
</Frame>

4. Once you're done, simply click the 'Create App' button:

<Frame>
  <img />
</Frame>

5. Once done, you'll be greeted with the screen shown below. We'll make a couple of changes here and it'll be ready to go.

<Frame>
  <img />
</Frame>

6. We'll need `Client Id` from the [Slack Developer's Dashboard](https://api.slack.com/apps) for configuring Slack Integration in the [Novu Web Dashboard](https://web.novu.co/integrations?utm_campaign=docs-guides-slack) later, so keep it handy.

<Frame>
  <img />
</Frame>

# Create a workflow in the Novu Web Dashboard

1. To create a workflow, head to the workflow section in the [Novu Web Dashboard](https://web.novu.co/workflows?utm_campaign=docs-guides-slack).
2. Click on the 'Add a workflow' button and select 'Blank workflow' from the dropdown.

<Frame>
  <img />
</Frame>

3. Once there, give your workflow a name and drag and drop the 'chat' option below the 'workflow trigger' step.

<Frame>
  <img />
</Frame>

4. You can also add variables in the Workflow Editor. For example, here I've added 'chatMsg' as a variable as I'll be sending data using it.

<Frame>
  <img />
</Frame>

<Info>Whatever is placed inside double braces is a variable.</Info>
5\. Make sure that you've turned on the Slack integration in the [Integrations Store](https://web.novu.co/integrations?utm_campaign=docs-guides-slack).

<Frame>
  <img />
</Frame>

6. To turn the Slack integration on, you'll need `Client Id`. You should have it already but if you don't, you can obtain it from the [Slack Developer's Dashboard](https://api.slack.com/apps).

<Frame>
  <img />
</Frame>

7. Once you have it, you need to plug it into the respective field in the [Slack Integration Settings](https://web.novu.co/integrations?utm_campaign=docs-guides-slack) on the Novu Web Dashboard.

<Frame>
  <img />
</Frame>

# Create the backend

The backend for this app is quite simple. Simply install the Novu package:

```bash theme={null}
npm install @novu/node

```

Now, create a route that you'll hit when called from the front end. We'll also need to add it to our Slack app (discussed below). For our demo app, this is the route I've created:

```jsx theme={null}
import express from "express";
import { chatController } from "../controller/chat.js";

const router = express.Router();

router.post("/sendChat", chatController);

export default router;
```

Now, we need a controller function to handle what is to be sent in the trigger's function payload. Here's the controller I wrote:

```jsx theme={null}
import { chat } from "../novu/novu.js"

export const chatController = async (req, res) => {
    const { chatMsg } = req.body;
    try {
        await chat(chatMsg);
        res.status(201).json({ message: "Message sent successfully" });
    } catch (error) {
        res.status(500).json({ message: error.message })
    }
}
```

<Info>Notice how we're expecting 'chatMsg' in our payload. This is why we added it as a variable in the workflow created earlier.</Info>

To make it modular, we’ll keep the trigger code in a separate function in a separate file, `novu.js`, in our case, which is as follows:

```jsx theme={null}
import { Novu, ChatProviderIdEnum } from '@novu/node';

export const chat = async (chatMsg) => {
    const novu = new Novu(process.env.YOUR_NOVU_API_KEY_HERE);
    await novu.subscribers.identify(process.env.SUB_ID, {
        firstName: 'newSubForSlackChat',
    });

    await novu.trigger('slack', {
        to: {
            subscriberId: process.env.SUB_ID
        },
        payload: {
            chatMsg: chatMsg
        }
    });
}
```

In this code snippet above, we're first initializing a new instance of Novu, then using it to 'identify' or [create](https://docs.novu.co/subscribers/subscribers#create-a-subscriber) a [subscriber](https://docs.novu.co/subscribers/subscribers).
<Info>The 'identify' method tries to find a subscriber with the given info. If it can't find any such subscriber, it creates a new subscriber with the supplied info.</Info>
After creating the subscriber, it runs the trigger code for the workflow we had created. You can find the trigger workflow by clicking on the 'Get Snippet' button on the workflow:

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

# Configure the Slack app

There are two ways to configure the Slack app. One is the Novu managed option and another the manually managed option.
Since the Novu managed is fairly straightforward, I'll demonstrate the manual method here. Follow along to set it up!

1. Goto 'Incoming Webhooks' in your Slack app settings and turn it on.

<Frame>
  <img />
</Frame>

2. Click on the 'Add New Webhook to Workspace':

<Frame>
  <img />
</Frame>

3. Now, go ahead and select the channel in which you want to send notifications and click 'allow'.

<Frame>
  <img />
</Frame>

4. Then, copy the 'webhookUrl' from Slack.

<Frame>
  <img />
</Frame>

5. Now, add the code below to the backend trigger functionality. Using this code, we are specifying what `webhookUrl` Novu will use to authenticate when using the Slack provider.

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Slack, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "slack",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "slack-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

In our case, we'll add it to the `Novu.js` file we created earlier so that the final file becomes :

```jsx theme={null}
import { Novu, ChatProviderIdEnum } from '@novu/node';

export const chat = async (chatMsg) => {
    const novu = new Novu(process.env.YOUR_NOVU_API_KEY_HERE);
    await novu.subscribers.identify(process.env.SUB_ID, {
        firstName: 'newSubForSlackChat',
    });

    await novu.subscribers.setCredentials(process.env.SUB_ID, ChatProviderIdEnum.Slack, {
        webhookUrl: process.env.SLACK_WEBHOOK_URL,
    });

    await novu.trigger('slack', {
        to: {
            subscriberId: process.env.SUB_ID
        },
        payload: {
            chatMsg: chatMsg
        }
    });
}
```

6. Finally, we'll add the route we'd created earlier to the redirect URL section, as shown:

<Frame>
  <img />
</Frame>

<Info>For demonstration purposes, I've added both the local as well as the deployed URL. You only need one depending on whether you're running this locally or have a deployed version.</Info>
Now, our backend is all done, our Slack is all setup and all we need to do is hit the URL

# Front end set up

For our demonstration purposes, the front end is pretty basic. All we have to do is have an input field to take the notification text in and send the payload. The front end code for this demo app is available on our [Github repo](https://github.com/novuhq/slack-app/tree/main/frontend).
And here's our app in all its glory!

<Frame>
  <img />
</Frame>

This is how we send Slack notifications using Novu!


# Angular Component Library
Source: https://v0.x-docs.novu.co/sdks/angular

Novu’s Angular library provides an Angular component wrapper over the Notification Center Web that you can use to integrate the notification center into your Angular application. 

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/notification-center-angular)

## Installation

```javascript theme={null}
npm install @novu/notification-center-angular
```

<Tip> If you're ready to start integrating in your Angular app, jump straight to our [Angular quickstart](/quickstarts/angular)</Tip>

Learn more about usage of the [Angular Component in detail.](/notification-center/client/angular)


# C#/.NET
Source: https://v0.x-docs.novu.co/sdks/dotnet

Connect a .NET application to Novu

Novu's .NET SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your C#/.NET application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-dotnet)

## Installation

```dotnet theme={null}
dotnet add package Novu
```

<Tip>
   If you're ready to start integrating in your .NET app, jump straight to
  our [.NET quickstart.](/quickstarts/.NET)
</Tip>

## Usage

```dotnet theme={null}
using Novu.DTO;
using Novu.Models;
using Novu;
...

var novuConfiguration = new NovuClientConfiguration
{
    // Defaults to https://api.novu.co/v1
    Url = "https://novu-api.my-domain.com/v1",
    ApiKey = "12345",
};

var novu = new NovuClient(novuConfiguration);

// OnboardEventPayload.cs
public class OnboardEventPayload
{
  [JsonProperty("username")]
  public string Username { get; set; }

  [JsonProperty("welcomeMessage")]
  public string WelcomeMessage { get; set; }
}

// MyFile.cs
var onboardingMessage = new OnboardEventPayload
{
  Username = "jdoe",
  WelcomeMessage = "Welcome to novu-dotnet"
};

var payload = new EventTriggerDataDto()
{
  EventName = "onboarding",
  To = { SubscriberId = "subscriberId" },
  Payload = onboardingMessage
};

var trigger = await novu.Event.Trigger(payload);

if (trigger.TriggerResponsePayloadDto.Acknowledged)
{
  Console.WriteLine("Trigger has been created.");
}
```


# Go SDK
Source: https://v0.x-docs.novu.co/sdks/go

Connect a Go application to Novu

Novu's Go SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Go application.

[Explore the source code on GitHub](https://github.com/novuhq/go-novu)

## Installation

```go theme={null}
go get github.com/novuhq/go-novu
```

<Tip> If you're ready to start integrating in your Go app, jump straight to our [Go quickstart.](/quickstarts/go)</Tip>

## Usage

```go theme={null}
package main

import (
	"context"
	"fmt"
	novu "github.com/novuhq/go-novu/lib"
	"log"
)

func main() {
	subscriberID := "<REPLACE_WITH_YOUR_SUBSCRIBER>"
	apiKey := "<REPLACE_WITH_YOUR_API_KEY>"
	eventId := "<REPLACE_WITH_YOUR_EVENT_ID>"

	ctx := context.Background()
	to := map[string]interface{}{
		"lastName":     "Doe",
		"firstName":    "John",
		"subscriberId": subscriberID,
		"email":        "john@doemail.com",
	}

	payload := map[string]interface{}{
		"name": "Hello World",
		"organization": map[string]interface{}{
			"logo": "https://happycorp.com/logo.png",
		},
	}

	data := novu.ITriggerPayloadOptions{To: to, Payload: payload}
	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

	resp, err := novuClient.EventApi.Trigger(ctx, eventId, data)
	if err != nil {
		log.Fatal("novu error", err.Error())
		return
	}

	fmt.Println(resp)

	// get integrations
	integrations, err := novuClient.IntegrationsApi.GetAll(ctx)
	if err != nil {
		log.Fatal("Get all integrations error: ", err.Error())
	}
	fmt.Println(integrations)
}
```


# Headless JavaScript Service
Source: https://v0.x-docs.novu.co/sdks/headless-javascript-service

Novu’s headless library provides users with a lightweight, completely unstyled, zero UI solution for integrating notification functionality into their web applications.

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/headless)

With just the essential API methods, users can easily incorporate our notification system into any framework or vanilla JavaScript project, without being constrained by our default UI or dependencies.

<Tip>
  If you're ready to start using the Headless Notification Center, check out our [guide!](/guides/headless-notification-center-guide)
</Tip>

Learn more about usage of the [Headless Services in detail.](/notification-center/client/headless/get-started)


# Iframe Embed Notification Center
Source: https://v0.x-docs.novu.co/sdks/iframe-embed

Embed a real-time notification center inside an iframe using our embedded script.

If you are using a (currently) unsupported client framework, you can use our embedded script.

Learn more about usage of the [Iframe Embed in detail.](/notification-center/client/iframe)


# SDKs & Client Libraries
Source: https://v0.x-docs.novu.co/sdks/introduction

You can interface with Novu's API either over REST, or via libraries for certain languages. Below is a list of our official, supported libraries.

<Note>It's important to note that our API and backend SDK are intended for use exclusively in server-side applications.
**Attempting to use them in a client-side application will result in Cross-Origin Resource Sharing (CORS) errors.**
This restriction ensures the security and integrity of our services.</Note>

## Client Side

The Client side libraries and components helps to add a fully functional notification center to your application.

<CardGroup>
  <Card title="Vue" icon="vuejs" href="/sdks/vue">
    Embed a real-time notification center component in your Vue application.
  </Card>

  <Card title="React" icon="react" href="/sdks/react">
    Embed a real-time notification center component in your React application.
  </Card>

  <Card title="Angular" icon="angular" href="/sdks/angular">
    Embed a real-time notification center component in your Angular application.
  </Card>

  <Card title="Web Component" icon="square-js" href="/sdks/web-component">
    Embed a real-time notification center component in your JavaScript
    application.
  </Card>

  <Card title="IFrame Embed" icon="html5" href="/sdks/iframe-embed">
    Embed a real-time notification center inside an iframe using our embedded
    script.
  </Card>

  <Card title="Headless JavaScript" icon="js" href="/sdks/headless-javascript-service">
    Embed a notification system into any framework or vanilla JavaScript
    project, without being constrained by our default UI or dependencies.
  </Card>
</CardGroup>

## Server Side

The Server side libraries helps to trigger notifications and interact with all of Novu’s API seamlessly.

<CardGroup>
  <Card
    title="Node.js"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="21.47" viewBox="0 0 512 314"><defs><linearGradient id="logosNodejs0" x1="68.188%" x2="27.823%" y1="17.487%" y2="89.755%"><stop offset="0%" stopColor="#41873F"/><stop offset="32.88%" stopColor="#418B3D"/><stop offset="63.52%" stopColor="#419637"/><stop offset="93.19%" stopColor="#3FA92D"/><stop offset="100%" stopColor="#3FAE2A"/></linearGradient><linearGradient id="logosNodejs1" x1="43.277%" x2="159.245%" y1="55.169%" y2="-18.306%"><stop offset="13.76%" stopColor="#41873F"/><stop offset="40.32%" stopColor="#54A044"/><stop offset="71.36%" stopColor="#66B848"/><stop offset="90.81%" stopColor="#6CC04A"/></linearGradient><linearGradient id="logosNodejs2" x1="-4413.77%" x2="5327.93%" y1="13.43%" y2="13.43%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs3" x1="-4.389%" x2="101.499%" y1="49.997%" y2="49.997%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs4" x1="-9713.77%" x2="27.93%" y1="36.21%" y2="36.21%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs5" x1="-103.861%" x2="100.797%" y1="50.275%" y2="50.275%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs6" x1="130.613%" x2="4.393%" y1="-211.069%" y2="201.605%"><stop offset="0%" stopColor="#41873F"/><stop offset="32.88%" stopColor="#418B3D"/><stop offset="63.52%" stopColor="#419637"/><stop offset="93.19%" stopColor="#3FA92D"/><stop offset="100%" stopColor="#3FAE2A"/></linearGradient><path id="logosNodejs7" d="M57.903 1.85a5.957 5.957 0 0 0-5.894 0L3.352 29.933c-1.85 1.04-2.89 3.005-2.89 5.085v56.286c0 2.08 1.156 4.045 2.89 5.085l48.657 28.085a5.957 5.957 0 0 0 5.894 0l48.658-28.085c1.849-1.04 2.89-3.005 2.89-5.085V35.019c0-2.08-1.157-4.045-2.89-5.085L57.903 1.85Z"/></defs><g fill="none"><path fill="#539E43" d="M253.11 313.094c-1.733 0-3.351-.462-4.854-1.271l-15.371-9.13c-2.312-1.272-1.156-1.734-.462-1.965c3.12-1.04 3.698-1.272 6.934-3.12c.347-.232.81-.116 1.156.115l11.789 7.05c.462.231 1.04.231 1.386 0l46.115-26.698c.462-.231.694-.694.694-1.271v-53.28c0-.579-.232-1.04-.694-1.272l-46.115-26.582c-.462-.232-1.04-.232-1.386 0l-46.115 26.582c-.462.231-.694.809-.694 1.271v53.28c0 .463.232 1.04.694 1.272l12.598 7.281c6.819 3.467 11.095-.578 11.095-4.623v-52.587c0-.693.578-1.387 1.387-1.387h5.894c.694 0 1.387.578 1.387 1.387v52.587c0 9.13-4.97 14.447-13.638 14.447c-2.658 0-4.738 0-10.633-2.89l-12.135-6.934c-3.005-1.733-4.854-4.97-4.854-8.437v-53.28c0-3.467 1.849-6.704 4.854-8.437l46.114-26.698c2.89-1.618 6.82-1.618 9.709 0l46.114 26.698c3.005 1.733 4.855 4.97 4.855 8.437v53.28c0 3.467-1.85 6.704-4.855 8.437l-46.114 26.698c-1.503.694-3.236 1.04-4.854 1.04Zm14.216-36.637c-20.225 0-24.386-9.246-24.386-17.105c0-.694.578-1.387 1.387-1.387h6.01c.693 0 1.271.462 1.271 1.156c.925 6.125 3.583 9.13 15.834 9.13c9.708 0 13.87-2.196 13.87-7.397c0-3.005-1.157-5.2-16.297-6.703c-12.598-1.272-20.457-4.045-20.457-14.1c0-9.362 7.86-14.91 21.035-14.91c14.793 0 22.075 5.086 23 16.18c0 .348-.116.694-.347 1.041c-.232.231-.578.462-.925.462h-6.01c-.578 0-1.156-.462-1.271-1.04c-1.387-6.356-4.97-8.437-14.447-8.437c-10.633 0-11.905 3.699-11.905 6.472c0 3.352 1.503 4.392 15.834 6.241c14.216 1.85 20.92 4.508 20.92 14.447c-.116 10.171-8.437 15.95-23.116 15.95Z"/><path fill="#333" d="M110.028 104.712c0-2.08-1.156-4.046-3.005-5.086l-49.004-28.2c-.81-.463-1.734-.694-2.658-.81h-.463c-.924 0-1.849.347-2.658.81l-49.004 28.2c-1.85 1.04-3.005 3.005-3.005 5.086l.116 75.817c0 1.04.578 2.08 1.502 2.543c.925.578 2.08.578 2.89 0l29.125-16.643c1.849-1.04 3.005-3.005 3.005-5.085v-35.482c0-2.08 1.155-4.045 3.005-5.085l12.366-7.166c.925-.578 1.965-.81 3.005-.81c1.04 0 2.08.232 2.89.81l12.366 7.166c1.85 1.04 3.005 3.004 3.005 5.085v35.482c0 2.08 1.156 4.045 3.005 5.085l29.125 16.643a2.82 2.82 0 0 0 3.005 0c.925-.463 1.503-1.503 1.503-2.543l-.116-75.817ZM345.571.347c-.924-.463-2.08-.463-2.89 0c-.924.578-1.502 1.502-1.502 2.542v75.125c0 .693-.346 1.386-1.04 1.849c-.693.346-1.387.346-2.08 0l-12.251-7.05a5.957 5.957 0 0 0-5.895 0l-49.004 28.316c-1.849 1.04-3.005 3.005-3.005 5.085v56.516c0 2.08 1.156 4.046 3.005 5.086l49.004 28.316a5.957 5.957 0 0 0 5.895 0l49.004-28.316c1.849-1.04 3.005-3.005 3.005-5.086V21.844c0-2.196-1.156-4.16-3.005-5.201L345.572.347Zm-4.507 143.776c0 .578-.231 1.04-.694 1.271l-16.758 9.708a1.714 1.714 0 0 1-1.503 0l-16.758-9.708c-.463-.231-.694-.809-.694-1.271v-19.417c0-.578.231-1.04.694-1.271l16.758-9.709a1.714 1.714 0 0 1 1.503 0l16.758 9.709c.463.23.694.809.694 1.271v19.417Zm167.584-19.879c1.85-1.04 2.89-3.005 2.89-5.086v-13.753c0-2.08-1.156-4.045-2.89-5.085l-48.657-28.2a5.957 5.957 0 0 0-5.895 0l-49.004 28.315c-1.85 1.04-3.005 3.005-3.005 5.085v56.517c0 2.08 1.156 4.045 3.005 5.085l48.657 27.738c1.85 1.04 4.046 1.04 5.78 0L489 178.45c.925-.463 1.503-1.503 1.503-2.543c0-1.04-.578-2.08-1.503-2.543l-49.235-28.316c-.925-.578-1.503-1.502-1.503-2.542v-17.683c0-1.04.578-2.08 1.503-2.543l15.371-8.784a2.821 2.821 0 0 1 3.005 0l15.372 8.784c.925.578 1.502 1.502 1.502 2.543v13.869c0 1.04.578 2.08 1.503 2.542a2.82 2.82 0 0 0 3.005 0l29.125-16.99Z"/><path fill="#539E43" d="M456.292 121.585a1.05 1.05 0 0 1 1.156 0l9.362 5.432c.346.232.577.578.577 1.04v10.865c0 .462-.23.809-.577 1.04l-9.362 5.432a1.05 1.05 0 0 1-1.156 0l-9.361-5.432c-.347-.231-.578-.578-.578-1.04v-10.864c0-.463.23-.81.578-1.04l9.361-5.433Z"/><g transform="translate(134.068 70.501)"><mask id="logosNodejs8" fill="#fff"><use href="#logosNodejs7"/></mask><use fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs0)" href="#logosNodejs7"/><g mask="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs8)"><path d="M51.893 1.85L3.121 29.933C1.27 30.974 0 32.94 0 35.02v56.286c0 1.387.578 2.658 1.502 3.698L56.285 1.156c-1.387-.231-3.005-.116-4.392.693Zm4.739 123.203c.462-.116.925-.347 1.387-.578l48.773-28.085c1.85-1.04 3.005-3.005 3.005-5.085V35.019c0-1.502-.694-3.005-1.734-4.045l-51.43 94.079Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs1)" d="M106.676 29.934L57.788 1.85a8.025 8.025 0 0 0-1.503-.578L1.502 95.12a6.082 6.082 0 0 0 1.619 1.387l48.888 28.085c1.387.809 3.005 1.04 4.507.577l51.432-94.078c-.347-.462-.81-.81-1.272-1.156Z"/></g><g mask="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs8)"><path d="M109.797 91.305V35.019c0-2.08-1.271-4.045-3.12-5.085L57.786 1.85a5.106 5.106 0 0 0-1.848-.693l53.511 91.42c.231-.347.347-.809.347-1.271ZM3.12 29.934C1.272 30.974 0 32.94 0 35.02v56.286c0 2.08 1.387 4.045 3.12 5.085l48.889 28.085c1.156.693 2.427.925 3.814.693L3.467 29.818l-.346.116Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs2)" fillRule="evenodd" d="m50.391.809l-.693.347h.924l-.231-.347Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs3)" fillRule="evenodd" d="M106.792 105.636c1.387-.809 2.427-2.196 2.89-3.698L56.053 10.402c-1.387-.231-2.89-.116-4.16.693L3.351 39.065l52.355 95.465a8.057 8.057 0 0 0 2.196-.693l48.889-28.2Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs4)" fillRule="evenodd" d="m111.3 104.712l-.347-.578v.809l.346-.231Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs5)" fillRule="evenodd" d="m106.792 105.636l-48.773 28.085a6.973 6.973 0 0 1-2.196.693l.925 1.734l54.089-31.32v-.694l-1.387-2.312c-.231 1.618-1.271 3.005-2.658 3.814Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs6)" fillRule="evenodd" d="m106.792 105.636l-48.773 28.085a6.973 6.973 0 0 1-2.196.693l.925 1.734l54.089-31.32v-.694l-1.387-2.312c-.231 1.618-1.271 3.005-2.658 3.814Z" transform="translate(0 -9.246)"/></g></g></g></svg>
}
    href="/sdks/nodejs"
  >
    Connect your Node app to Novu via the Node.js SDK.
  </Card>

  <Card
    title="PHP"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#deviconPhp0)" d="M0 64c0 18.593 28.654 33.667 64 33.667c35.346 0 64-15.074 64-33.667c0-18.593-28.655-33.667-64-33.667C28.654 30.333 0 45.407 0 64Z"/><path fill="#777bb3" d="M64 95.167c33.965 0 61.5-13.955 61.5-31.167c0-17.214-27.535-31.167-61.5-31.167S2.5 46.786 2.5 64c0 17.212 27.535 31.167 61.5 31.167Z"/><path d="M34.772 67.864c2.793 0 4.877-.515 6.196-1.53c1.306-1.006 2.207-2.747 2.68-5.175c.44-2.27.272-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.464l-2.473 12.732zM20.173 83.547a.694.694 0 0 1-.68-.828l6.557-33.738a.695.695 0 0 1 .68-.561h14.134c4.442 0 7.748 1.206 9.827 3.585c2.088 2.39 2.734 5.734 1.917 9.935c-.333 1.711-.905 3.3-1.7 4.724a15.818 15.818 0 0 1-3.128 3.92c-1.531 1.432-3.264 2.472-5.147 3.083c-1.852.604-4.232.91-7.07.91h-5.724l-1.634 8.408a.695.695 0 0 1-.682.562z"/><path fill="#fff" d="M34.19 55.826h3.891c3.107 0 4.186.682 4.553 1.089c.607.674.723 2.097.331 4.112c-.439 2.257-1.253 3.858-2.42 4.756c-1.194.92-3.138 1.386-5.773 1.386h-2.786l2.205-11.342zm6.674-8.1H26.731a1.39 1.39 0 0 0-1.364 1.123L18.81 82.588a1.39 1.39 0 0 0 1.363 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.151c2.912 0 5.364-.318 7.287-.944c1.977-.642 3.796-1.731 5.406-3.237a16.522 16.522 0 0 0 3.259-4.087c.831-1.487 1.429-3.147 1.775-4.931c.86-4.423.161-7.964-2.076-10.524c-2.216-2.537-5.698-3.823-10.349-3.823zM30.301 68.557h4.471c2.963 0 5.17-.557 6.62-1.675c1.451-1.116 2.428-2.98 2.938-5.591c.485-2.508.264-4.277-.665-5.308c-.931-1.03-2.791-1.546-5.584-1.546h-5.036l-2.743 14.12m10.563-19.445c4.252 0 7.353 1.117 9.303 3.348c1.95 2.232 2.536 5.347 1.76 9.346c-.322 1.648-.863 3.154-1.625 4.518c-.764 1.366-1.76 2.614-2.991 3.747c-1.468 1.373-3.097 2.352-4.892 2.935c-1.794.584-4.08.875-6.857.875h-6.296l-1.743 8.97h-7.35l6.558-33.739h14.133"/><path d="M69.459 74.577a.694.694 0 0 1-.682-.827l2.9-14.928c.277-1.42.209-2.438-.19-2.87c-.245-.263-.979-.704-3.15-.704h-5.256l-3.646 18.768a.695.695 0 0 1-.683.56h-7.29a.695.695 0 0 1-.683-.826l6.558-33.739a.695.695 0 0 1 .682-.561h7.29a.695.695 0 0 1 .683.826L64.41 48.42h5.653c4.307 0 7.227.758 8.928 2.321c1.733 1.593 2.275 4.14 1.608 7.573l-3.051 15.702a.695.695 0 0 1-.682.56h-7.407z"/><path fill="#fff" d="M65.31 38.755h-7.291a1.39 1.39 0 0 0-1.364 1.124l-6.557 33.738a1.39 1.39 0 0 0 1.363 1.654h7.291a1.39 1.39 0 0 0 1.364-1.124l3.537-18.205h4.682c2.168 0 2.624.463 2.641.484c.132.14.305.795.019 2.264l-2.9 14.927a1.39 1.39 0 0 0 1.364 1.654h7.408a1.39 1.39 0 0 0 1.363-1.124l3.051-15.7c.715-3.686.103-6.45-1.82-8.217c-1.836-1.686-4.91-2.505-9.398-2.505h-4.81l1.421-7.315a1.39 1.39 0 0 0-1.364-1.655zm0 1.39l-1.743 8.968h6.496c4.087 0 6.907.714 8.457 2.14c1.553 1.426 2.017 3.735 1.398 6.93l-3.052 15.699h-7.407l2.901-14.928c.33-1.698.208-2.856-.365-3.474c-.573-.617-1.793-.926-3.658-.926h-5.829l-3.756 19.327H51.46l6.558-33.739h7.292z"/><path d="M92.136 67.864c2.793 0 4.878-.515 6.198-1.53c1.304-1.006 2.206-2.747 2.679-5.175c.44-2.27.273-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.463l-2.475 12.732zM77.54 83.547a.694.694 0 0 1-.682-.828l6.557-33.738a.695.695 0 0 1 .682-.561H98.23c4.442 0 7.748 1.206 9.826 3.585c2.089 2.39 2.734 5.734 1.917 9.935a15.878 15.878 0 0 1-1.699 4.724a15.838 15.838 0 0 1-3.128 3.92c-1.53 1.432-3.265 2.472-5.147 3.083c-1.852.604-4.232.91-7.071.91h-5.723l-1.633 8.408a.695.695 0 0 1-.683.562z"/><path fill="#fff" d="M91.555 55.826h3.891c3.107 0 4.186.682 4.552 1.089c.61.674.724 2.097.333 4.112c-.44 2.257-1.254 3.858-2.421 4.756c-1.195.92-3.139 1.386-5.773 1.386h-2.786l2.204-11.342zm6.674-8.1H84.096a1.39 1.39 0 0 0-1.363 1.123l-6.558 33.739a1.39 1.39 0 0 0 1.364 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.15c2.911 0 5.364-.318 7.286-.944c1.978-.642 3.797-1.731 5.408-3.238a16.52 16.52 0 0 0 3.258-4.086c.832-1.487 1.428-3.147 1.775-4.931c.86-4.423.162-7.964-2.076-10.524c-2.216-2.537-5.697-3.823-10.35-3.823zM87.666 68.557h4.47c2.964 0 5.17-.557 6.622-1.675c1.45-1.116 2.428-2.98 2.936-5.591c.487-2.508.266-4.277-.665-5.308c-.93-1.03-2.791-1.546-5.583-1.546h-5.035Zm10.563-19.445c4.251 0 7.354 1.117 9.303 3.348c1.95 2.232 2.537 5.347 1.759 9.346c-.32 1.648-.862 3.154-1.624 4.518c-.763 1.366-1.76 2.614-2.992 3.747c-1.467 1.373-3.097 2.352-4.892 2.935c-1.793.584-4.078.875-6.856.875h-6.295l-1.745 8.97h-7.35l6.558-33.739h14.133"/><defs><radialGradient id="deviconPhp0" cx="0" cy="0" r="1" gradientTransform="translate(38.426 42.169) scale(84.04136)" gradientUnits="userSpaceOnUse"><stop stopColor="#AEB2D5"/><stop offset=".3" stopColor="#AEB2D5"/><stop offset=".75" stopColor="#484C89"/><stop offset="1" stopColor="#484C89"/></radialGradient></defs></svg>
}
    href="/sdks/php"
  >
    Connect your PHP app to Novu via the PHP SDK.
  </Card>

  <Card title="Laravel" icon="laravel" href="/sdks/laravel">
    Connect your Laravel app to Novu via the Laravel SDK.
  </Card>

  <Card
    title="Python"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="34.87" viewBox="0 0 256 255"><defs><linearGradient id="logosPython0" x1="12.959%" x2="79.639%" y1="12.039%" y2="78.201%"><stop offset="0%" stopColor="#387EB8"/><stop offset="100%" stopColor="#366994"/></linearGradient><linearGradient id="logosPython1" x1="19.128%" x2="90.742%" y1="20.579%" y2="88.429%"><stop offset="0%" stopColor="#FFE052"/><stop offset="100%" stopColor="#FFC331"/></linearGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosPython0)" d="M126.916.072c-64.832 0-60.784 28.115-60.784 28.115l.072 29.128h61.868v8.745H41.631S.145 61.355.145 126.77c0 65.417 36.21 63.097 36.21 63.097h21.61v-30.356s-1.165-36.21 35.632-36.21h61.362s34.475.557 34.475-33.319V33.97S194.67.072 126.916.072ZM92.802 19.66a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.13Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosPython1)" d="M128.757 254.126c64.832 0 60.784-28.115 60.784-28.115l-.072-29.127H127.6v-8.745h86.441s41.486 4.705 41.486-60.712c0-65.416-36.21-63.096-36.21-63.096h-21.61v30.355s1.165 36.21-35.632 36.21h-61.362s-34.475-.557-34.475 33.32v56.013s-5.235 33.897 62.518 33.897Zm34.114-19.586a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.131a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13Z"/></svg>
}
    href="/sdks/python"
  >
    Connect your Python app to Novu via the Python SDK.
  </Card>

  <Card
    title="Kotlin"
    icon={
<svg
    xmlns="http://www.w3.org/2000/svg"
    width="20"
    height="20"
    viewBox="0 0 256 256"
  >
    <defs>
      <linearGradient
        id="logosKotlinIcon0"
        x1="99.991%"
        x2=".01%"
        y1="-.011%"
        y2="100.01%"
      >
        <stop offset=".344%" stopColor="#E44857" />
        <stop offset="46.89%" stopColor="#C711E1" />
        <stop offset="100%" stopColor="#7F52FF" />
      </linearGradient>
    </defs>
    <path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosKotlinIcon0)" d="M256 256H0V0h256L128 127.949z" />
  </svg>}
    href="/quickstarts/kotlin"
  >
    Connect your Kotlin app to Novu via the Kotlin SDK.
  </Card>

  <Card
    title="Java"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="#0074BD" d="M47.617 98.12s-4.767 2.774 3.397 3.71c9.892 1.13 14.947.968 25.845-1.092c0 0 2.871 1.795 6.873 3.351c-24.439 10.47-55.308-.607-36.115-5.969zm-2.988-13.665s-5.348 3.959 2.823 4.805c10.567 1.091 18.91 1.18 33.354-1.6c0 0 1.993 2.025 5.132 3.131c-29.542 8.64-62.446.68-41.309-6.336z"/><path fill="#EA2D2E" d="M69.802 61.271c6.025 6.935-1.58 13.17-1.58 13.17s15.289-7.891 8.269-17.777c-6.559-9.215-11.587-13.792 15.635-29.58c0 .001-42.731 10.67-22.324 34.187z"/><path fill="#0074BD" d="M102.123 108.229s3.529 2.91-3.888 5.159c-14.102 4.272-58.706 5.56-71.094.171c-4.451-1.938 3.899-4.625 6.526-5.192c2.739-.593 4.303-.485 4.303-.485c-4.953-3.487-32.013 6.85-13.743 9.815c49.821 8.076 90.817-3.637 77.896-9.468zM49.912 70.294s-22.686 5.389-8.033 7.348c6.188.828 18.518.638 30.011-.326c9.39-.789 18.813-2.474 18.813-2.474s-3.308 1.419-5.704 3.053c-23.042 6.061-67.544 3.238-54.731-2.958c10.832-5.239 19.644-4.643 19.644-4.643zm40.697 22.747c23.421-12.167 12.591-23.86 5.032-22.285c-1.848.385-2.677.72-2.677.72s.688-1.079 2-1.543c14.953-5.255 26.451 15.503-4.823 23.725c0-.002.359-.327.468-.617z"/><path fill="#EA2D2E" d="M76.491 1.587S89.459 14.563 64.188 34.51c-20.266 16.006-4.621 25.13-.007 35.559c-11.831-10.673-20.509-20.07-14.688-28.815C58.041 28.42 81.722 22.195 76.491 1.587z"/><path fill="#0074BD" d="M52.214 126.021c22.476 1.437 57-.8 57.817-11.436c0 0-1.571 4.032-18.577 7.231c-19.186 3.612-42.854 3.191-56.887.874c0 .001 2.875 2.381 17.647 3.331z"/></svg>
}
    href="/sdks/java"
  >
    Connect your Java app to Novu via the Java SDK.
  </Card>

  <Card
    title="Ruby"
    icon={<svg xmlns="http://www.w3.org/2000/svg" width="20" height="19.93" viewBox="0 0 256 255"><defs><linearGradient id="logosRuby0" x1="84.75%" x2="58.254%" y1="111.399%" y2="64.584%"><stop offset="0%" stopColor="#FB7655"/><stop offset="0%" stopColor="#FB7655"/><stop offset="41%" stopColor="#E42B1E"/><stop offset="99%" stopColor="#900"/><stop offset="100%" stopColor="#900"/></linearGradient><linearGradient id="logosRuby1" x1="116.651%" x2="1.746%" y1="60.89%" y2="19.288%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby2" x1="75.774%" x2="38.978%" y1="219.327%" y2="7.829%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby3" x1="50.012%" x2="66.483%" y1="7.234%" y2="79.135%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E57252"/><stop offset="46%" stopColor="#DE3B20"/><stop offset="99%" stopColor="#A60003"/><stop offset="100%" stopColor="#A60003"/></linearGradient><linearGradient id="logosRuby4" x1="46.174%" x2="49.932%" y1="16.348%" y2="83.047%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E4714E"/><stop offset="56%" stopColor="#BE1A0D"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby5" x1="36.965%" x2="49.528%" y1="15.594%" y2="92.478%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="18%" stopColor="#E46342"/><stop offset="40%" stopColor="#C82410"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby6" x1="13.609%" x2="85.764%" y1="58.346%" y2="-46.717%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="54%" stopColor="#C81F11"/><stop offset="99%" stopColor="#BF0905"/><stop offset="100%" stopColor="#BF0905"/></linearGradient><linearGradient id="logosRuby7" x1="27.624%" x2="50.745%" y1="21.135%" y2="79.056%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="31%" stopColor="#DE4024"/><stop offset="99%" stopColor="#BF190B"/><stop offset="100%" stopColor="#BF190B"/></linearGradient><linearGradient id="logosRuby8" x1="-20.667%" x2="104.242%" y1="122.282%" y2="-6.342%"><stop offset="0%" stopColor="#BD0012"/><stop offset="0%" stopColor="#BD0012"/><stop offset="7%" stopColor="#FFF"/><stop offset="17%" stopColor="#FFF"/><stop offset="27%" stopColor="#C82F1C"/><stop offset="33%" stopColor="#820C01"/><stop offset="46%" stopColor="#A31601"/><stop offset="72%" stopColor="#B31301"/><stop offset="99%" stopColor="#E82609"/><stop offset="100%" stopColor="#E82609"/></linearGradient><linearGradient id="logosRuby9" x1="58.792%" x2="11.964%" y1="65.205%" y2="50.128%"><stop offset="0%" stopColor="#8C0C01"/><stop offset="0%" stopColor="#8C0C01"/><stop offset="54%" stopColor="#990C00"/><stop offset="99%" stopColor="#A80D0E"/><stop offset="100%" stopColor="#A80D0E"/></linearGradient><linearGradient id="logosRubya" x1="79.319%" x2="23.088%" y1="62.754%" y2="17.888%"><stop offset="0%" stopColor="#7E110B"/><stop offset="0%" stopColor="#7E110B"/><stop offset="99%" stopColor="#9E0C00"/><stop offset="100%" stopColor="#9E0C00"/></linearGradient><linearGradient id="logosRubyb" x1="92.88%" x2="59.841%" y1="74.122%" y2="39.704%"><stop offset="0%" stopColor="#79130D"/><stop offset="0%" stopColor="#79130D"/><stop offset="99%" stopColor="#9E120B"/><stop offset="100%" stopColor="#9E120B"/></linearGradient><linearGradient id="logosRubyc" x1="56.57%" x2="3.105%" y1="101.717%" y2="11.993%"><stop offset="0%" stopColor="#8B2114"/><stop offset="0%" stopColor="#8B2114"/><stop offset="43%" stopColor="#9E100A"/><stop offset="99%" stopColor="#B3100C"/><stop offset="100%" stopColor="#B3100C"/></linearGradient><linearGradient id="logosRubyd" x1="30.87%" x2="92.471%" y1="35.599%" y2="100.694%"><stop offset="0%" stopColor="#B31000"/><stop offset="0%" stopColor="#B31000"/><stop offset="44%" stopColor="#910F08"/><stop offset="99%" stopColor="#791C12"/><stop offset="100%" stopColor="#791C12"/></linearGradient><radialGradient id="logosRubye" cx="32.001%" cy="40.21%" r="69.573%" fx="32.001%" fy="40.21%"><stop offset="0%" stopColor="#A80D00"/><stop offset="0%" stopColor="#A80D00"/><stop offset="99%" stopColor="#7E0E08"/><stop offset="100%" stopColor="#7E0E08"/></radialGradient><radialGradient id="logosRubyf" cx="13.549%" cy="40.86%" r="88.386%" fx="13.549%" fy="40.86%"><stop offset="0%" stopColor="#A30C00"/><stop offset="0%" stopColor="#A30C00"/><stop offset="99%" stopColor="#800E08"/><stop offset="100%" stopColor="#800E08"/></radialGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby0)" d="m197.467 167.764l-145.52 86.41l188.422-12.787L254.88 51.393l-57.414 116.37Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby1)" d="M240.677 241.257L224.482 129.48l-44.113 58.25l60.308 53.528Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby2)" d="m240.896 241.257l-118.646-9.313l-69.674 21.986l188.32-12.673Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby3)" d="m52.744 253.955l29.64-97.1L17.16 170.8l35.583 83.154Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby4)" d="M180.358 188.05L153.085 81.226l-78.047 73.16l105.32 33.666Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby5)" d="m248.693 82.73l-73.777-60.256l-20.544 66.418l94.321-6.162Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby6)" d="M214.191.99L170.8 24.97L143.424.669l70.767.322Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby7)" d="m0 203.372l18.177-33.151l-14.704-39.494L0 203.372Z"/><path fill="#FFF" d="m2.496 129.48l14.794 41.963l64.283-14.422l73.39-68.207l20.712-65.787L143.063 0L87.618 20.75c-17.469 16.248-51.366 48.396-52.588 49c-1.21.618-22.384 40.639-32.534 59.73Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby8)" d="M54.442 54.094c37.86-37.538 86.667-59.716 105.397-40.818c18.72 18.898-1.132 64.823-38.992 102.349c-37.86 37.525-86.062 60.925-104.78 42.027c-18.73-18.885.515-66.032 38.375-103.558Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby9)" d="m52.744 253.916l29.408-97.409l97.665 31.376c-35.312 33.113-74.587 61.106-127.073 66.033Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubya)" d="m155.092 88.622l25.073 99.313c29.498-31.016 55.972-64.36 68.938-105.603l-94.01 6.29Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubyb)" d="M248.847 82.833c10.035-30.282 12.35-73.725-34.966-81.791l-38.825 21.445l73.791 60.346Z"/><path fill="#9E1209" d="M0 202.935c1.39 49.979 37.448 50.724 52.808 51.162l-35.48-82.86L0 202.935Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubye)" d="M155.232 88.777c22.667 13.932 68.35 41.912 69.276 42.426c1.44.81 19.695-30.784 23.838-48.64l-93.114 6.214Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubyf)" d="m82.113 156.507l39.313 75.848c23.246-12.607 41.45-27.967 58.121-44.42l-97.434-31.428Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubyc)" d="m17.174 171.34l-5.57 66.328c10.51 14.357 24.97 15.605 40.136 14.486c-10.973-27.311-32.894-81.92-34.566-80.814Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubyd)" d="m174.826 22.654l78.1 10.96c-4.169-17.662-16.969-29.06-38.787-32.623l-39.313 21.663Z"/></svg>

}
    href="/quickstarts/ruby"
  >
    Connect your Ruby app to Novu via the Ruby SDK.
  </Card>

  <Card
    title="Go"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="13.13" viewBox="0 0 512 192"><path fill="#00ACD7" d="m292.533 13.295l1.124.75c13.212 8.725 22.685 20.691 28.917 35.15c1.496 2.243.499 3.49-2.493 4.237l-5.063 1.296c-11.447 2.949-20.53 5.429-31.827 8.378l-6.443 1.678c-2.32.574-2.96.333-5.428-2.477l-.348-.399c-3.519-3.988-6.155-6.652-10.817-9.03l-.899-.443c-15.705-7.727-30.911-5.484-45.12 3.74c-16.952 10.968-25.677 27.172-25.428 47.364c.25 19.942 13.96 36.395 33.654 39.137c16.951 2.244 31.16-3.739 42.378-16.452c2.244-2.743 4.238-5.734 6.73-9.224h-48.11c-5.235 0-6.481-3.24-4.736-7.478l.864-2.035c3.204-7.454 8.173-18.168 11.4-24.294l.704-1.319c.862-1.494 2.612-3.513 5.977-3.513h80.224c3.603-11.415 9.449-22.201 17.246-32.407c18.198-23.931 40.135-36.396 69.8-41.63c25.427-4.488 49.359-1.995 71.046 12.713c19.694 13.461 31.909 31.66 35.15 55.59c4.237 33.654-5.485 61.075-28.668 84.508c-16.453 16.702-36.645 27.172-59.829 31.908c-6.73 1.247-13.461 1.496-19.942 2.244c-22.685-.499-43.376-6.98-60.826-21.937c-12.273-10.61-20.727-23.648-24.928-38.828a104.937 104.937 0 0 1-10.47 16.89c-17.949 23.683-41.381 38.39-71.046 42.38c-24.43 3.24-47.115-1.497-67.058-16.454c-18.447-13.96-28.917-32.407-31.66-55.34c-3.24-27.173 4.737-51.603 21.19-73.041c17.7-23.184 41.132-37.891 69.8-43.126c22.999-4.16 45.037-1.595 64.936 11.464ZM411.12 49.017l-.798.178c-23.183 5.235-38.14 19.942-43.624 43.375c-4.488 19.444 4.985 39.138 22.934 47.115c13.71 5.983 27.421 5.235 40.633-1.496c19.694-10.22 30.413-26.175 31.66-47.613c-.25-3.24-.25-5.734-.749-8.227c-4.436-24.401-26.664-38.324-50.056-33.332ZM116.416 94.564c.997 0 1.496.748 1.496 1.745l-.499 5.983c0 .997-.997 1.745-1.745 1.745l-54.344-.249c-.997 0-1.246-.748-.748-1.496l3.49-6.232c.499-.748 1.496-1.496 2.493-1.496h49.857ZM121.9 71.63c.997 0 1.496.748 1.247 1.496l-1.995 5.983c-.249.997-1.246 1.495-2.243 1.495l-117.912.25c-.997 0-1.246-.499-.748-1.247l5.235-6.73c.499-.748 1.745-1.247 2.742-1.247H121.9Zm12.963-22.934c.997 0 1.246.748.748 1.496l-4.238 6.481c-.499.748-1.745 1.496-2.493 1.496l-90.24-.25c-.998 0-1.247-.498-.749-1.246l5.235-6.73c.499-.748 1.745-1.247 2.742-1.247h88.995Z"/></svg>
}
    href="/sdks/go"
  >
    Connect your Golang app to Novu via the Go SDK.
  </Card>

  <Card
    title=".NET"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 256 256"><g fill="none"><rect width="256" height="256" fill="#512BD4" rx="60"/><path fill="#fff" d="M24.052 168.943c-2.236 0-4.138-.731-5.703-2.194c-1.566-1.501-2.349-3.283-2.349-5.347c0-2.101.783-3.902 2.349-5.403c1.565-1.5 3.466-2.251 5.703-2.251c2.274 0 4.194.751 5.76 2.251c1.603 1.501 2.404 3.302 2.404 5.403c0 2.064-.801 3.846-2.404 5.347c-1.566 1.463-3.486 2.194-5.76 2.194Zm89.415-1.238H98.929l-38.304-59.318a26.371 26.371 0 0 1-2.404-4.672h-.336c.298 1.726.447 5.422.447 11.087v52.903H45.471V87H60.96l37.018 57.912c1.566 2.402 2.572 4.052 3.02 4.953h.223c-.372-2.139-.559-5.759-.559-10.863V87h12.805v80.705Zm62.631 0h-45.014V87h43.225v11.369h-29.916v22.849h27.568v11.312h-27.568v23.863h31.705v11.312Zm63.973-69.336h-23.038v69.336h-13.309V98.369h-22.982V87h59.329v11.369Z"/></g></svg>
}
    href="/sdks/dotnet"
  >
    Connect your C#/.NET app to Novu via the .NET SDK.
  </Card>
</CardGroup>


# Java SDK
Source: https://v0.x-docs.novu.co/sdks/java

Connect a Java application to Novu

Novu's Java SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Java application.

[Explore the source code on GitHub.](https://github.com/novuhq/novu-java)

## Installation

Maven users:

```java theme={null}
<!--add dependency-->
<dependency>
    <groupId>co.novu</groupId>
    <artifactId>novu-java</artifactId>
    <version>{use-latest-version}</version>
</dependency>
```

The latest version can be found [on GitHub.](https://github.com/novuhq/novu-java#installation)

Gradle users:

```groovy theme={null}
implementation 'co.novu:novu-java:{latest-version}'
```

Sync your project, and you should have the artifacts downloaded.

<Tip> If you're ready to start integrating in your Java app, jump straight to our [Java quickstart.](/quickstarts/java)</Tip>

## Usage

```java theme={null}
import co.novu.sdk.Novu;

public class Main {
    public static void main(String[] args) {
        String apiKey = "INSERT_API_KEY_HERE";
        // Using the API Key only
        Novu novu = new Novu(apiKey);

        // Using the Config Param
        NovuConfig novuConfig = new NovuConfig(apiKey);
        Novu novu = new Novu(novuConfig);

        // Sample usage
        novu.triggerEvent(event);
    }
}

// Sign up on https://web.novu.co and grab your API key from https://web.novu.co/settings
```


# Kotlin SDK
Source: https://v0.x-docs.novu.co/sdks/kotlin

Connect a Kotlin application to Novu

Novu's Kotlin SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Kotlin application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-kotlin)

## Installation

Maven users:

```xml theme={null}
<dependency>
  <groupId>co.novu</groupId>
  <artifactId>novu-kotlin</artifactId>
  <version>{use-latest-version}</version>
</dependency>
```

The latest version can be found [on GitHub.](https://github.com/novuhq/novu-kotlin#installation)

Gradle users:

```groovy theme={null}
implementation 'co.novu:novu-kotlin:{use-latest-version}' //Groovy

implementation ("co.novu:novu-kotlin:{use-latest-version}") //Kotlin
```

Sync your project, and you should have the artifacts downloaded.

<Tip> If you're ready to start integrating in your Kotlin app, jump straight to our [Kotlin quickstart.](/quickstarts/kotlin)</Tip>

## Usage

```kotlin theme={null}

// without changing the backend URL
import co.novu.Novu
import co.novu.extentions.environments

fun main() {
    val novu = Novu(apiKey = "NOVU_API_KEY")
    val environment = novu.environments()
    println(environment)
}

```


# Laravel
Source: https://v0.x-docs.novu.co/sdks/laravel

Connect a Laravel application to Novu

Novu's Laravel SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Laravel application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-laravel)

## Installation

```php theme={null}
composer require novu/novu-laravel
```

<Tip> If you're ready to start integrating in your Laravel app, jump straight to our [Laravel quickstart.]()</Tip>

## Usage

```php theme={null}
use Novu\Laravel\Facades\Novu;

$response = Novu::triggerEvent([
    'name' => '<WORKFLOW_TRIGGER_IDENTIFIER_FROM_DASHBOARD>',
    'payload' => ['customVariables' => 'Hello'],
    'to' => [
        'subscriberId' => '<SUBSCRIBER_ID_FROM_DASHBOARD>',
        'phone' => '07983887777'
    ]
])->toArray();

// or you can use the novu() helper function like so:
novu()->triggerEvent([
    'name' => '<WORKFLOW_TRIGGER_IDENTIFIER_FROM_DASHBOARD>',
    'payload' => ['customVariables' => 'Hello'],
    'to' => [
        'subscriberId' => '<SUBSCRIBER_ID_FROM_DASHBOARD>',
        'phone' => '07983887777'
    ]
])->toArray();
```


# NodeJS SDK
Source: https://v0.x-docs.novu.co/sdks/nodejs

Connect a Node.js application to Novu

Novu's Node.js SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Node.js application.

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/node)

## Installation

```javascript theme={null}
npm install @novu/node 
```

<Tip> If you're ready to start integrating in your Node.js app, jump straight to our [Nodejs quickstart.](/quickstarts/nodejs)</Tip>

## Usage

```javascript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<USER_IDENTIFIER>',
    email: 'test@email.com',
    firstName: 'John',
    lastName: 'Doe',
  },
  payload: {
    organization: {
      logo: 'https://evilcorp.com/logo.png',
    },
  },
});
```


# PHP SDK
Source: https://v0.x-docs.novu.co/sdks/php

Connect a PHP application to Novu

Novu's PHP SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your PHP application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-php)

## Installation

```php theme={null}
composer require unicodeveloper/novu
```

<Tip> If you're ready to start integrating in your PHP app, jump straight to our [PHP quickstart.](/quickstarts/php)</Tip>

## Usage

```php theme={null}
use Novu\SDK\Novu;

$novu = new Novu(<INSERT_API_KEY_HERE>);

// Sign up on https://web.novu.co and grab your API key from https://web.novu.co/settings

$response = $novu->triggerEvent([
    'name' => '<REPLACE_WITH_TEMPLATE_NAME_FROM_ADMIN_PANEL>',
    'payload' => ['customVariables' => 'Hello'],
    'to' => [
        'subscriberId' => '<SUBSCRIBER_IDENTIFIER_FROM_ADMIN_PANEL>',
        'phone' => '07983882186'
    ]
])->toArray();
```


# Python SDK
Source: https://v0.x-docs.novu.co/sdks/python

Connect a Python application to Novu

Novu's Python SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Python application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-python)

## Installation

```python theme={null}
# Via pip
pip install novu

# Via poetry
poetry add novu
```

<Tip> If you're ready to start integrating in your Python app, jump straight to our [Python quickstart.](/quickstarts/python)</Tip>

## Usage

```python theme={null}
from novu.api import EventApi

url = "https://api.novu.co"
api_key = "<NOVU_API_KEY>"

# You can sign up on https://web.novu.co to get your API key from https://web.novu.co/settings

novu = EventApi(url, api_key).trigger(
    name="digest-workflow-example",  # This is the Workflow ID. It can be found on the workflow page.
    recipients="<SUBSCRIBER_IDENTIFIER>", # The subscriber ID can be gotten from the dashboard.
    payload={},  # Your custom Novu payload goes here
)
```


# React Component
Source: https://v0.x-docs.novu.co/sdks/react

Novu’s React library provides a fully functional and embeddable notification center component with real-time updates that you can drop into your React application.

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/notification-center)

## Installation

```javascript theme={null}
npm install @novu/notification-center
```

<Tip> If you're ready to start integrating in your React app, jump straight to our [quickstart](/quickstarts/react)</Tip>

Learn more about usage of the [React Component in detail.](/notification-center/client/react/get-started)


# Ruby SDK
Source: https://v0.x-docs.novu.co/sdks/ruby

Connect a Ruby application to Novu.

Novu's Ruby SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Ruby application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-ruby)

## Installation

```javascript theme={null}
gem install novu
```

<Tip> If you're ready to start integrating in your Ruby app, jump straight to our [Ruby quickstart.](/quickstarts/ruby)</Tip>

## Usage

```ruby theme={null}
require 'novu'

client = Novu::Client.new(access_token: 'YOUR_NOVU_API_TOKEN')

payload = {
    'name' => 'Trigger1',
    'payload' => { # optional
        'first-name' => 'Adam' # optional
    },
    'to' => {
        'subscriberId' => '7789'
    },
    'transactionId' => '89kjfke9893' #optional
}

client.trigger_event(payload)
```


# Vue library
Source: https://v0.x-docs.novu.co/sdks/vue

Novu’s Vue library provides a Vue component wrapper over the Notification Center Web that you can use to integrate the notification center into your Vue application. 

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/notification-center-vue)

## Installation

```javascript theme={null}
npm install @novu/notification-center-vue
```

<Tip> If you're ready to start integrating in your Vue app, jump straight to the [Vue quickstart.](/quickstarts/vue)</Tip>

Learn more about usage of the [Vue Component in detail.](/notification-center/client/vue)


# Web Component Library
Source: https://v0.x-docs.novu.co/sdks/web-component

Novu’s Web Component library provides a fully functional and embeddable notification center widget with real-time updates that you can drop into any web application.

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/notification-center)

## Installation

You can use the web component in two ways:

* As an ESM Module
* As a bundled CDN version

<Tip> If you're ready to start integrating in your web app, jump straight to the [Web component quickstart.](/quickstarts/vanillajs)</Tip>

Learn more about usage of the [Web Component in detail.](/notification-center/client/web-component)


# Security and Compliance
Source: https://v0.x-docs.novu.co/security-and-compliance/security

Common questions related to security, compliance, privacy policy and terms and conditions

### What should I do if I have regulatory or security issues with PII?

We regularly work with big companies and are happy to help and support you with guidance, and various compliances including reports to ease your security and legal team. If you have concerns about PII, you can use our OS version, Novu Hybrid-Cloud enterprise plan, or reach out to us at [sales@novu.co](mailto:sales@novu.co), [support@novu.co](mailto:support@novu.co), or Discord.

### I need my data to reside in the EU, can it be done?

Yes, as part of our GDPR compliance we have our cloud version available on both EU (Frankfurt), as well as US (Virginia).

### Are you GDPR compliant?

Yes, you can see the complete compliance report on our [security page](https://trust.novu.co/). Novu also decided to take the extra step and provide separate data residency in both the EU and the US.

### I created my account in the EU/US, can I switch to the other one?

Not exactly, to keep data residency intact we cannot simply copy or move data between data warehouses across US and EU. However if you have the need please contact us at [sales@novu.co](mailto:sales@novu.co)

### Are you SOC 2 compliant?

Yes, Novu Cloud is SOC 2 Type II compliant, we have made sure to do penetration tests, security training, evidence collection, and SDL. You can see live control updated on our [security page](https://trust.novu.co/), and ask for our security report as well at [sales@novu.co](mailto:sales@novu.co).

### Are you ISO 27001 compliant?

Yes, Novu Cloud is ISO27001 compliant, we have made sure to go through both Stage 1 and Stage 2 audits, and fully define ISMS requirements. From entirely creating our organization processes, defining organization risk assessment policies, and building organization Incident Response & Disaster Recovery plans.

### Where is my data stored?

Based on the selected solution there are a couple of options. On the OS option based on where you choose to store it :) As to the Novu Cloud solution, you can choose the EU (Frankfurt) or the US (Virginia). In case you are working on the Novu Hybrid-Cloud solution we will help you deploy your data inside your select network.

### For how long user data is stored?

By default, data is stored using the following TTL values

* Notifications (for 1 month)
* Jobs (for 1 month)
* Message (for in-app messages - 12 months, for all other messages - 1 month)
* Execution Details (for 1 month)
* Subscribers, Workflows, Feeds, Layouts (Not deleted automatically, can be deleted by the user at any time)

If you want to delete any specific data or information, reach out to us at [support@novu.co](mailto:support@novu.co)

### How to report any vulnerability or security issue?

We are equally committed to our users and their data’s security. We highly appreciate it if someone shares security vulnerabilities with us. Feel free to use the [github issue](https://github.com/novuhq/novu/security/advisories/new) or email us at [security@novu.co](mailto:security@novu.co).


# AWS
Source: https://v0.x-docs.novu.co/self-hosting-novu/aws

Learn how to deploy Novu to AWS

Amazon Web Services (AWS) is a cloud computing platform by Amazon, providing a wide range of on-demand services like computing power, storage, and databases over the internet.
It enables businesses and individuals to avoid managing physical infrastructure and offers features for computing, storage, databases, analytics, machine learning, and more.
AWS is known for its scalability, flexibility, and global network of data centers.
Learn more about [AWS](https://docs.aws.amazon.com/)

## Deploying on EC2 with the Docker Compose File

Deploying Novu on EC2 with Docker Compose involves several steps.

In general, the steps are as follows:

1. **Set up an EC2 Instance**: Create an instance on AWS EC2. We reccomend a bare minimum of 4 CPU Cores and 16GB of RAM.
2. **Install Docker**: Once you have your instance up and running, SSH into it and install Docker. You can do this by running the following commands:

```bash theme={null}
sudo yum update -y sudo amazon-linux-extras install docker;
sudo service docker start sudo usermod -a -G docker
ec2-user
```

3. **Install Docker Compose**: Docker Compose will allow you to easily manage your application which will consist of multiple Docker containers.
   Install it by running:

```bash theme={null}
sudo curl -L "https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose;
sudo chmod +x /usr/local/bin/docker-compose
```

4. **Deploy Novu**: Now, clone the Novu repository and navigate to the directory containing the docker-compose.yml file.
   To start your Novu instance, simply run:

```bash theme={null}
docker-compose up -d
```

Please note, there are user reports indicating an issue with volume persistence when deploying Novu on EC2 with Docker Compose.
You can see the discussions about this problem [here](https://github.com/novuhq/novu/issues/3339) as we do not provide official support for these types of deployments.
This is something to be aware of when deploying in this manner, and you may need to adopt additional strategies for data persistence.
Be sure to consult the Novu documentation as well as any relevant EC2 and Docker documentation for any necessary details related to your specific deployment needs.
Additionally, keep in mind that these general steps may not cover all nuances or requirements of your particular use case or the specific configuration of the Novu application.
Always ensure any deployment follows best practices for security, scalability, and maintainability.

# 🏗️ This page is still in creation process

We believe in the power of collaboration. If you have insights to share or would like to contribute to the development of this page, we welcome your input. To get involved, follow these steps:

**Open an Issue:** If you've identified an area for improvement or have a suggestion, start by opening an issue in our repository. This allows us to track and discuss the proposed changes.

**Create a Pull Request (PR):** Once you're ready to contribute, fork our repository and create a branch. Implement your changes within this branch and submit a pull request to our **Staging branch**.

By following these steps, you're helping us enhance the quality and depth of our resources. We appreciate your effort in making this page an even more valuable asset.

Your contributions drive progress. Let's build together!


# Deploy with Docker
Source: https://v0.x-docs.novu.co/self-hosting-novu/deploy-with-docker

Learn how to deploy Novu with Docker

Docker compose is the easiest way to get started with self-hosted Novu.

## Before you begin

You need the following installed in your system:

* [Docker](https://docs.docker.com/engine/install/) and [docker-compose](https://docs.docker.com/compose/install/)
* [Git](https://git-scm.com/downloads)

<iframe />

<Info>In above loom video `local/deployment` directory is used. Now it has been moved to `docker/community`. Follow below mentioned steps.</Info>

## Quick Start

### Get the code

Clone the Novu repo and enter the docker directory locally:

```bash theme={null}
# Get the code
git clone --depth 1 https://github.com/novuhq/novu

# Go to the docker community folder
cd novu/docker/community

# Copy the example env file
cp .env.example .env

# Start Novu
docker-compose -f docker-compose.yml up
```

Now visit [http://localhost:4200](http://localhost:4200/) to start using Novu.

## Securing your setup

While we provide you with some example secrets for getting started, you should NEVER deploy your Novu setup using the defaults provided.

Update the `.env` file with your own secrets.

### Required Variables:

* `JWT_SECRET`: Used by the API to generate JWT keys.
* `STORE_ENCRYPTION_KEY`: Used to encrypt/decrypt the provider credentials. It must be 32 characters long.
* `HOST_NAME`: Host name of your installation. This will be the base URL of your installation. For example, if you are deploying to server with ip `35.154.137.80`, then you should set this to `http://35.154.137.80`.

`REDIS_CACHE_SERVICE_HOST` and `REDIS_HOST` can have same value for small deployments. For larger deployments, it is recommended to use separate Redis instances for caching and queue management.

## Configuration

To keep the setup simple, we made some choices that may not be optimal for production:

* the database is in the same machine as the servers
* the storage uses localstack instead of S3

We strongly recommend that you decouple your database before deploying.

### Triggering events with custom installation

When self-hosting Novu, in order to trigger an event you must first create a new `Novu` object and configure it with the proper `backendUrl`.

```tsx theme={null}
import { Novu } from '@novu/node';

const config = {
  backendUrl: '<REPLACE_WITH_BACKEND_URL>',
};

const novu = new Novu('<API_KEY>', config);

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {},
});
```

### Pointing IFrame embed to custom installation

When using the IFrame embed to attach the notification center rather than the React component, you need to specify the `backendUrl` and the `socketUrl` when initializing the iframe.

```html theme={null}
<script>
  novu.init(
    '<REPLACE_APPLICATION_ID>',
    {
      unseenBadgeSelector: '#unseen-badge',
      bellSelector: '#notification-bell',
      backendUrl: 'https://api.example.com',
      socketUrl: 'https://ws.example.com',
    },
    {}
  );
</script>

```

### Using React Component with custom installation

See [Use your own backend and socket URL](https://docs.novu.co/notification-center/react/react-components#use-your-own-backend-and-socket-url).

### Caching

We are introducing the first stage of caching in our system to improve performance and efficiency. Caching is turned off by default, but can easily be activated by setting the following environment variables:

* REDIS\_CACHE\_SERVICE\_HOST
* REDIS\_CACHE\_SERVICE\_PORT

Currently, we are caching data in the most heavily loaded areas of the system: the widget requests such as feed and unseen count, as well as common DAL requests during the execution of trigger event flow. These are the most heavily used areas of our system, and we hope that by implementing caching in these areas, we can improve performance in the near future.

### Reverse-Proxy / Load Balancers

To implement a reverse-proxy or load balancer in front of Novu, you need to set the GLOBAL\_CONTEXT\_PATH for the base path of the application.
This is the path that the application will be served from after the domain.
For example:

* company.com/novu
  This is used to set the base path for the application, and is used to set the base path for the API, web, and websocket connections.

The following environment variables are used to set the context path for each public service that Novu provides:
API\_CONTEXT\_PATH
WIDGET\_CONTEXT\_PATH
WS\_CONTEXT\_PATH
WEB\_CONTEXT\_PATH

These allow you to set the context path for each service independently or dependently of the GLOBAL\_CONTEXT\_PATH.

For example, if I was using a reverse proxy to serve Novu from company.com/novu,
I would set the GLOBAL\_CONTEXT\_PATH to novu,
and then set the API\_CONTEXT\_PATH to api,
the WIDGET\_CONTEXT\_PATH to widget,
the WS\_CONTEXT\_PATH to ws,
and the WEB\_CONTEXT\_PATH to web.

This would produce the following urls:

* API: company.com/novu/api
* WIDGET: company.com/novu/widget
* WS: company.com/novu/ws
* WEB: company.com/novu/web

However the Service context path can be used entirely independently of the GLOBAL\_CONTEXT\_PATH.

For example, if I wanted to expose the api as novu-api, I would set the API\_CONTEXT\_PATH to novu-api without setting the GLOBAL\_CONTEXT\_PATH.
This would producte the following url:

* API: company.com/novu-api

<Note> These env variables should be present on all services novu provides due to tight coupling.</Note>


# Introduction
Source: https://v0.x-docs.novu.co/self-hosting-novu/introduction



Self-hosting Novu involves setting up and maintaining your communication infrastructure using your own servers.
While this offers full control and customization,
some features which are available only for Novu’s cloud-managed won't be available in a self-hosted environment.

## Minimum System Requirements

For basic installation, a server with 16GB RAM and 8 CPUs is fine. However, specifications vary depending on requirements and here are sample specifications for handling 1M plus notifications:

* If everything is running on one machine, then at least 36 vCPU and 64GB of RAM.
* If services are running across containers, then it is recommended to run 3 containers per service, each container having 2 vCPU and 4GB of RAM.
* If you're using Kubernetes, then the K8 system needs to have 36 vCPU and 64GB of RAM at least in the cluster to run the servers.
* On AWS, a c6g.8xlarge instance with 32 vCPU and 64GB of RAM.
* In all cases, you need to also have 2 Redis clusters with the queue one having an Append only log file active (AOL) to prevent instances of job loss during an outage,  a MongoDB cluster equivalent to a M20 or greater on Atlas, and 10GB of S3 storage.
* Lastly, the queue Redis instance should be 8GB MINIMUM as there needs to be enough space to handle spikes in notifications or the whole system will brick.

<Note>Note that these specifications are subject to your requirements, the scale of your operations, and should be adjusted as needed.</Note>
<Warning>Github login is not available in self-hosting. If you're self hosting Novu, use your email and password to log into your Novu account!</Warning>


# Kubernetes
Source: https://v0.x-docs.novu.co/self-hosting-novu/kubernetes

Learn how to deploy Novu with K8s

<Warning>
  We do not plan to support any official public kubernetes deployment at this time.
  This guide is to help assist advanced users who want to deploy Novu on their own kubernetes cluster.
</Warning>

Kubernetes is an open-source platform that automates the deployment, scaling, and management of containerized applications.

You can find a community driven [helm deployment](https://github.com/novuhq/novu/blob/next/docker/kubernetes/helm/README.md) in our repository.

## Novu Web Container Does not Run on Kubernetes

Due to the way we build our web container image,
you will need to build your own image and push it to your own registry.
This is due to us compiling the frontend when the container starts.

You can follow our [dev-deploy-web workflow](https://github.com/novuhq/novu/blob/next/.github/workflows/dev-deploy-web.yml)
to see how we build our web container image.
You can also use this workflow to build your own image, you will just need to remove all of the steps after the deploy to netlify step.

<Note>
  Only need to do this IF you do not allow root only access on your cluster.
</Note>


# Object Storage (S3, Blob, GCS)
Source: https://v0.x-docs.novu.co/self-hosting-novu/object-storage

Using S3 as a storage backend for your application

For local development we use [LocalStack.cloud](https://localstack.cloud/). It is utilized as a local emulation of S3 during development.

This might be beneficial for testing and development purposes before transitioning to actual S3 service like in a production environment.

## AWS S3

### Configuration

AWS S3 requires the following environment variables to be set:

1. S3\_REGION:
2. S3\_LOCAL\_STACK (optional): S3 endpoint to connect to, leave blank if your connecting directly to AWS
3. S3\_BUCKET\_NAME: Name of the bucket to use
4. STORAGE\_SERVICE: Name of the storage service to use, 'AWS' or 'LOCALSTACK' for S3.

### Bucket Configuration

In general, access to the S3 bucket is very permissive.

The following process is used to manage access to the S3 bucket.

General design:

* public read access (for logo and email attachments—all data is open for read to anyone)
* write access is via pre-signed url (client-side PUT to S3 after server-side request)
* private write access (get, put, delete)
* objects are written with organisationIdTenancy/objectId (at least for brand logos)

Specifics for access:

* CORS access on bucket (this is documented)
* bucket object do not need versioning (as all uploads are deemed unique)
* ACL on buckets is 'public-read' (as part of the pre-signed URLs)
* image uploads (as pre-signed) could also have rules to limit (DENY policy) on extension types (although UI also does this but leaves open a vector)
* AWS (specific): ensure that Allow owenership controls is 'BucketOwnerPreferred' to allow ACL access (rather than role/user) (ie PutObjectAcl)

### Example Terraform

```terraform theme={null}
/**
 * This sets up an S3 bucket for notifications assets (eg photos, documents). The bucket is
 * PUBLIC for read access and needs to be opened up to the API (which is deployed as an ECS task).
 *
 * It also needs to be opened up to worker (to create pre-signed urls for uploads)
 *
 * This bucket is:
 *  * public read access
 *  * private write access to the credentials (added onto the user rather than onto the bucket)
 */

#
# WARNING: this bucket uses IAM Policies and ACL for access
#
#  - @see https://binaryguy.tech/aws/s3/iam-policies-vs-s3-policies-vs-s3-bucket-acls/#:~:text=The%20biggest%20advantage%20of%20using,well%20as%20objects%20in%20it.
#  - @see https://aws.amazon.com/blogs/security/iam-policies-and-bucket-policies-and-acls-oh-my-controlling-access-to-s3-resources/
#  - @see https://stackoverflow.com/questions/47815526/s3-bucket-policy-vs-access-control-list
#
#
# TF: https://www.terraform.io/docs/providers/aws/r/s3_bucket.html
# AWS: http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/s3api/create-bucket.html
resource "aws_s3_bucket" "notifications" {
  bucket = "${var.environment}-notifications-data"
  # removed for upgrade to aws provider 4.0
  # see https://registry.terraform.io/providers/hashicorp/aws/latest/docs/guides/version-4-upgrade#acl-argument
  # acl    = "private"

  tags = {
    Environment = var.environment
    Terraform   = true
  }
}


# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_public_access_block
resource "aws_s3_bucket_public_access_block" "notifications" {
  bucket                  = aws_s3_bucket.notifications.id
  block_public_acls       = false
  # This feature protects your bucket from accidentally getting a policy that would enable public access
  # We WANT public access for read
  block_public_policy     = false
  ignore_public_acls      = false
  restrict_public_buckets = false
}


# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_ownership_controls
# this is required when setting the 'public-read' acl—without it it fails on apply
resource "aws_s3_bucket_ownership_controls" "notifications" {
  bucket = aws_s3_bucket.notifications.id

  rule {
    object_ownership = "BucketOwnerPreferred"
  }
}

# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_acl
resource "aws_s3_bucket_acl" "notifications" {
  bucket = aws_s3_bucket.notifications.id
  # Defaults to private
  # ["private" "public-read" "public-read-write" "authenticated-read" "aws-exec-read" "log-delivery-write"]
  acl    = "public-read"

  depends_on = [
    aws_s3_bucket_ownership_controls.notifications,
    aws_s3_bucket_public_access_block.notifications,
  ]
}

#
# Note: no point on having vesrioning enabled
#

#
# Restricted CORS policy but increased headers exposed (that could be further restrictred)
#
# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_cors_configuration
# AWS: https://docs.amplify.aws/lib/storage/getting-started/q/platform/js/#amazon-s3-bucket-cors-policy-setup
resource "aws_s3_bucket_cors_configuration" "notifications" {
  bucket = aws_s3_bucket.notifications.id

  cors_rule {
    allowed_headers = ["*"]
    allowed_methods = [
      "GET",
      "HEAD",
      "PUT",
    ]
    allowed_origins = ["/* OWN FQDN */"]
    expose_headers  = [
      "x-amz-server-side-encryption",
      "x-amz-request-id",
      "x-amz-id-2",
      "x-amz-meta-tag",
      "ETag"
    ]
    max_age_seconds = 3000
  }
}

resource "aws_s3_bucket_policy" "notifications" {
  bucket = aws_s3_bucket.notifications.id
  policy = data.aws_iam_policy_document.notifications-user.json
}

# [Data] IAM policy to define S3 permissions
#
# Restricting users files types to avoid problems (note: hand helds love to upload PDFs)
#
# TF: https://www.terraform.io/docs/providers/aws/d/iam_policy_document.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html
data "aws_iam_policy_document" "notifications-user" {
  statement {
    sid    = "DenyNonImage"
    effect = "Deny"
    principals {
      identifiers = [aws_iam_user.notifications.arn]
      type        = "AWS"
    }
    actions = [
      # NOTE: this is an ACL permissions
      "s3:PutObjectAcl",
    ]
    not_resources = [
      "${aws_s3_bucket.notifications.arn}/*.png",
      "${aws_s3_bucket.notifications.arn}/*.jpg",
      "${aws_s3_bucket.notifications.arn}/*.jpeg",
      "${aws_s3_bucket.notifications.arn}/*.gif"
    ]
  }
  # NOTE: these rules exist on the user policy
/*
  statement {
    effect = "Allow"
    principals {
      type        = "AWS"
      identifiers = [aws_iam_user.notifications.arn]
    }
    actions = [
      "s3:GetObject",
      "s3:DeleteObject",
      "s3:ListBucket",
      "s3:PutObject",
      # this is the magic spice, because the perms are created via ACL (rather than roles)
      "s3:PutObjectAcl"
    ]
    resources = [
      "${aws_s3_bucket.notifications.arn}*/
/*",
    ]
  }
*/
}

#######################

# TF: https://www.terraform.io/docs/providers/aws/r/iam_policy.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html
resource "aws_iam_policy" "s3" {
  name        = "ecs-app-${var.environment}-s3"
  description = "Access from the ecs tasks to s3 buckets"
  policy      = data.aws_iam_policy_document.s3.json
}

# [Data] IAM policy to define S3 permissions
# TF: https://www.terraform.io/docs/providers/aws/d/iam_policy_document.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html
data "aws_iam_policy_document" "s3" {
  statement {
    sid     = ""
    effect  = "Allow"
    actions = [
      "s3:DeleteObject",
      "s3:GetObject",
      "s3:PutObject",
      # this is the magic spice, because the perms are created via ACL (rather than roles)
      "s3:PutObjectAcl",
      "s3:ListBucket"
    ]
    resources = [
      "arn:aws:s3:::${var.assets_bucket}/*"
    ]
  }
}

######################

# Attaches a managed IAM policy to an IAM role for the ecs tasks
# TF: https://www.terraform.io/docs/providers/aws/r/iam_role_policy_attachment.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html
resource "aws_iam_role_policy_attachment" "s3" {
  role       = aws_iam_role.app_task.name  # need your role attached to whatever is doing the execution (eg workload task)
  policy_arn = aws_iam_policy.s3.arn
}
```

## Azure Blob Storage Configuration

### Configuration

Azure Blob Storage requires the following environment variables to be set:

### Required

1. STORAGE\_SERVICE: Name of the storage service to use, 'AZURE' Azure Blob.
2. AZURE\_CONTAINER\_NAME: The name of the container in your Azure Storage account that you wish to use for your blob storage.
3. AZURE\_ACCOUNT\_NAME: The name of your Azure Storage account. This is used to form the URL at which your blob storage is accessible.
4. AZURE\_ACCOUNT\_KEY: The access key for your Azure Storage account. This is used to authenticate requests made against your blob storage.
5. AZURE\_HOST\_NAME: The host name of your Azure Storage account . This is used to form the URL at which your blob storage is accessible. [Ref](https://learn.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-nodejs?tabs=managed-identity%2Croles-azure-portal%2Csign-in-azure-cli#upload-blobs-to-a-container).

### Bucket Configuration

TBD

## Google Cloud Storage Configuration

### Configuration

Google Cloud Storage requires the following environment variables to be set:

1. `GCS_BUCKET_NAME`: Name of the bucket to use.
2. `GOOGLE_APPLICATION_CREDENTIALS`: Path to the service account key file.
3. `STORAGE_SERVICE`: Name of the storage service to use, 'GCS' for Google Cloud Storage.

### Bucket Configuration

TBD


# Get changes
Source: https://v0.x-docs.novu.co/api-reference/changes/get-changes

get /v1/changes

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.changes.get();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getChanges();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.changes({
      'page' => 1, # optional
      'limit' => 10, # optional
      'promoted' => 'hello'
  })
  ```

  ```python Python theme={null}
  from novu.api import ChangeApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = ChangeApi(url, api_key).list(
      page = "<Page to retrieve>",
      limit = "<Size of page>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.changes(query = {});
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      totalCount: 0,
      data: [data],
      pageSize: 0,
      page: 0
  }
  ```
</ResponseExample>


# Get changes count
Source: https://v0.x-docs.novu.co/api-reference/changes/get-changes-count

get /v1/changes/count

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.changes.getCount();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getChangesCount()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.count_changes()
  ```

  ```python Python theme={null}
  from novu.api import ChangeApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = ChangeApi(url, api_key).count(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.countChanges();
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      data: 0
  }
  ```
</ResponseExample>


# Get api keys
Source: https://v0.x-docs.novu.co/api-reference/environments/get-api-keys

get /v1/environments/api-keys

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.environmets.getApiKeys();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getEnvironmentsAPIKeys()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.api_keys()
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.apiKeys();
      }
  }
  ```

  ```python Python theme={null}
  from novu.api import EnvironmentApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  apiKeys = EnvironmentApi(url, api_key).api_keys()
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.apiKeys

  fun main() {
      val novu = Novu(apiKey = "API_KEY")
      val apiKeys = novu.apiKeys()
      println(apiKeys)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
       --url https://api.novu.co/v1/environments/api-keys \
       --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "key": "string",
        "_userId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Get current environment
Source: https://v0.x-docs.novu.co/api-reference/environments/get-current-environment

get /v1/environments/me

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.environments.getCurrent();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->getCurrentEnvironment()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.current_environment()
  ```

  ```python Python theme={null}
  from novu.api import EnvironmentApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = EnvironmentApi(url, api_key).current(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.currentEnvironment();
      }
  }
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.currentEnvironment

  fun main() {
      val novu = Novu(apiKey = "API_KEY")
      val currentEnvironment = novu.currentEnvironment()
      println(currentEnvironment)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
       --url https://api.novu.co/v1/environments/me \
       --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "_organizationId": "string",
      "identifier": "string",
      "apiKeys": [
        {
          "key": "string",
          "_userId": "string"
        }
      ],
      "_parentId": "string"
    }
  }
  ```
</ResponseExample>


# List all environments
Source: https://v0.x-docs.novu.co/api-reference/environments/get-environments

get /v1/environments
This API returns a list of environments for the current organization. 
    Each environment contains its configuration, API keys (if user has access), and metadata.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.environments.getAll();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getEnvironments()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.environments()
  ```

  ```python Python theme={null}
  from novu.api import EnvironmentApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = EnvironmentApi(url, api_key).list(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.environments();
      }
  }
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.environments

  fun main() {
      val novu = Novu(apiKey = "API_KEY")
      val environment = novu.environments()
      println(environment)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
       --url https://api.novu.co/v1/environments \
       --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "name": "string",
        "_organizationId": "string",
        "identifier": "string",
        "apiKeys": [
          {
            "key": "string",
            "_userId": "string"
          }
        ],
        "_parentId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Regenerate api keys
Source: https://v0.x-docs.novu.co/api-reference/environments/regenerate-api-keys

post /v1/environments/api-keys/regenerate

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.environmets.regenerateApiKeys();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $key = $novu->regenerateEnvironmentsAPIKeys()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.regenerate_api_keys()
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.regenerateApiKeys();
      }
  }
  ```

  ```python Python theme={null}
  from novu.api import EnvironmentApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  regenerateApiKey = EnvironmentApi(url, api_key).regenerate_api_key()
  ```

  ```bash cURL theme={null}
  curl --request POST \
       --url https://api.novu.co/v1/environments/api-keys/regenerate \
       --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "key": "string",
        "_userId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Broadcast event to all
Source: https://v0.x-docs.novu.co/api-reference/events/broadcast-event-to-all

post /v1/events/trigger/broadcast
Trigger a broadcast event to all existing subscribers, could be used to send announcements, etc.
      In the future could be used to trigger events to a subset of subscribers based on defined filters.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.events.broadcast("<WORKFLOW_TRIGGER_IDENTIFIER>", {
    payload: {
      customKey: "customValue",
      customKey1: {
        nestedkey1: "nestedValue1"
      }
    },
    overrides: {
      email: {
        from: "support@novu.co"
      }
    },
    tenant: "tenantIdentifier"
  })
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->broadcastEvent([
      'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
      'payload' => ['customVariables' => 'Hello'],
      'transactionId' => '<REPLACE_WITH_TRANSACTION_ID>'
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'name' => 'Trigger',
      'payload' => {
          'first-name' => 'Adam',
          'last-name' => 'Eve'
      },
      'transactionId' => 'sw900999as' #optional
  }
  client.broadcast_event(payload)
  ```

  ```bash cURL theme={null}
  curl -X POST https://api.novu.co/v1/events/trigger/broadcast \
    -H "Authorization: ApiKey <NOVU_API_KEY>" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "<WORKFLOW_TRIGGER_IDENTIFIER>",
      "payload": {
        "customKey": "customValue",
        "customKey1": {
          "nestedkey1": "nestedValue1"
        }
      },
      "overrides": {
        "email": {
          "from": "support@novu.co"
        }
      },
      "tenant": "tenantIdentifier"
    }'
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
  	apiKey := "<NOVU_API_KEY>"
  	ctx := context.Background()

  	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

      name := interface{}{"<WORKFLOW_TRIGGER_IDENTIFIER>"}

  	payload := map[string]interface{}{
  		"name": "Hello World",
  		"organization": map[string]interface{}{
  			"logo": "https://happycorp.com/logo.png",
  		},
  	}

      data := novu.BroadcastEventToAll{Name: name, Payload: payload}

  	resp, err := novuClient.EventApi.BroadcastToAll(ctx, data)

  	if err != nil {
  		log.Fatal("novu error", err.Error())
  		return
  	}
  }
  ```

  ```python Python theme={null}
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  novu = EventApi(url, api_key).broadcast(
      name="<WORKFLOW_TRIGGER_IDENTIFIER>",
      payload={"customVariable": "value"},  # Optional
  )
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.events.requests.TriggerEventRequest;
  import co.novu.api.events.responses.TriggerEventResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest = new SubscriberRequest();
          subscriberRequest.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest.setFirstName("<FIRST_NAME>");
          subscriberRequest.setLastName("<LAST_NAME>");
          subscriberRequest.setPhone("<PHONE_NUMBER>");
          subscriberRequest.setAvatar("<AVATAR>");
          subscriberRequest.setSubscriberId("<SUBSCRIBER_ID>");

          TriggerEventRequest triggerEventRequest = new TriggerEventRequest();
          triggerEventRequest.setName("<NAME>"); 
          triggerEventRequest.setTo(subscriberRequest);
          triggerEventRequest.setPayload(Collections.singletonMap("<CUSTOM_VARIABLE_NAME>", "<CUSTOM_VARIABLE_VALUE>"));

          TriggerEventResponse response = novu.broadcastEvent(triggerEventRequest);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var testRecord = new TestRecord
  {
      Message = "This is a test message"
  };

  var dto = new EventTriggerDataDto()
  {
      EventName = "<WORKFLOW_TRIGGER_IDENTIFIER>",
      To =
      {
          SubscriberId = "<UNIQUE_SUBSCRIBER_IDENTIFIER>"
      },
      Payload = testRecord
  };

  var trigger = await novu.Event.TriggerBroadcastAsync(dto);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "acknowledged": true,
          "status": "processed",
          "transactionId": "string"
      }
  }
  ```
</ResponseExample>


# Bulk trigger event
Source: https://v0.x-docs.novu.co/api-reference/events/bulk-trigger-event

post /v1/events/trigger/bulk

      Using this endpoint you can trigger multiple events at once, to avoid multiple calls to the API.
      The bulk API is limited to 100 events per request.
    

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.events.bulkTrigger([
    {
      name: "<WORKFLOW_TRIGGER_IDENTIFIER>",
      to: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload: {
        customKey: "customValue",
        customKey1: {
          nestedkey1: "nestedValue1"
        }
      },
      overrides: {
        email: {
          from: "support@novu.co"
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    },
    {
      name: "<WORKFLOW_TRIGGER_IDENTIFIER>",
      to: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload: {
        customKey: "customValue",
        customKey1: {
          nestedkey1: "nestedValue1"
        }
      },
      overrides: {
        email: {
          from: "support@novu.co"
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    }
  ])
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->bulkTriggerEvent([
      [
          'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>', 
          'to' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>', 
          'payload' => ['customVariables' => 'Hello']
      ],
      [
          'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>', 
          'to' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>', 
          'payload' => ['customVariables' => 'World']
      ],
  ])->toArray();
  ```

  ```bash cURL theme={null}

  curl -X POST https://api.novu.co/v1/events/trigger/bulk \
    -H "Authorization: ApiKey <NOVU_API_KEY>" \
    -H "Content-Type: application/json" \
    -d '{
      "events": [
        {
          "name": "<WORKFLOW_TRIGGER_IDENTIFIER>",
          "to": {
            "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
            "email": "john@doemail.com"
          },
          "payload": {
            "customKey": "customValue",
            "customKey1": {
              "nestedkey1": "nestedValue1"
            }
          },
          "overrides": {
            "email": {
              "from": "support@novu.co"
            }
          },
          "actor": "actorId",
          "tenant": "tenantIdentifier"
        },
        {
          "name": "<WORKFLOW_TRIGGER_IDENTIFIER>",
          "to": {
            "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
            "email": "janet@doemail.com"
          },
          "payload": {
            "customKey": "customValue",
            "customKey1": {
              "nestedkey1": "nestedValue1"
            }
          },
          "overrides": {
            "email": {
              "from": "support@novu.co"
            }
          },
          "actor": "actorId",
          "tenant": "tenantIdentifier"
        }
      ]
    }'


  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'events' => [
          {
              'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
              'payload' => { # optional
                  'first-name' => 'Adam' # optional
              },
              'to' => {
                  'subscriberId' => '7789'
              },
              'transactionId' => '89kjfke9893' #optional
          },
          {
              'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
              'payload' => { # optional
                  'last-name' => 'Eve' # optional
              },
              'to' => {
                  'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
              },
              'transactionId' => 'sw900999as' #optional
          }
      ]
  }
  client.trigger_bulk_event(payload)
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
  	apiKey := "<NOVU_API_KEY>"
  	ctx := context.Background()

  	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

      event1 := novu.BulkTriggerOptions{
          Name: []string{"<WORKFLOW_TRIGGER_IDENTIFIER>"},
          To: map[string]interface{}{
              "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
              "email":        "john@doemail.com",
  	    },
          Payload: map[string]interface{}{
              "name": "Hello World",
              "organization": map[string]interface{}{
                  "logo": "https://happycorp.com/logo.png",
              },
  	    }
      }
      event2 := novu.BulkTriggerOptions{
          Name: []string{"<WORKFLOW_TRIGGER_IDENTIFIER>"},
          To: map[string]interface{}{
              "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
              "email":        "janet@doemail.com",
  	    },
          Payload: map[string]interface{}{
              "name": "Hello World",
              "organization": map[string]interface{}{
                  "logo": "https://happycorp.com/logo.png",
              },
  	    }
      }

      triggerPayload := []novu.BulkTriggerOptions{ event1, event2}

  	resp, err := novuClient.EventApi.TriggerBulk(ctx, triggerPayload)

  	if err != nil {
  		log.Fatal("novu error", err.Error())
  		return
  	}
  }
  ```

  ```python Python theme={null}
  from novu.dto.event import InputEventDto
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  event_1 = InputEventDto(
      name="<WORKFLOW_TRIGGER_IDENTIFIER>",  # The workflow ID is the slug of the workflow name. It can be found on the workflow page.
      recipients="<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload={},  # Your custom Novu payload goes here
  )
  event_2 = InputEventDto(
      name="<WORKFLOW_TRIGGER_IDENTIFIER>",
      recipients="<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload={},
  )

  novu = EventApi(url, api_key).trigger_bulk(
      events=[event1,event2]
  )
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.events.requests.TriggerEventRequest;
  import co.novu.api.events.pojos.BulkTriggerEventRequest;
  import co.novu.api.events.responses.BulkTriggerEventResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest = new SubscriberRequest();
          subscriberRequest.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest.setFirstName("<FIRST_NAME>");
          subscriberRequest.setLastName("<LAST_NAME>");
          subscriberRequest.setPhone("<PHONE_NUMBER>");
          subscriberRequest.setAvatar("<AVATAR>");
          subscriberRequest.setSubscriberId("<SUBSCRIBER_ID>");

          TriggerEventRequest triggerEventRequest1 = new TriggerEventRequest();
          triggerEventRequest1.setName("<NAME>");
          triggerEventRequest1.setTo(subscriberRequest);
          triggerEventRequest1.setPayload(Collections.singletonMap("<CUSTOM_VARIABLE_NAME>", "<CUSTOM_VARIABLE_VALUE>"));
          
          TriggerEventRequest triggerEventRequest2 = new TriggerEventRequest();
          triggerEventRequest2.setName("<NAME>");
          triggerEventRequest2.setTo(subscriberRequest);
          triggerEventRequest2.setPayload(Collections.singletonMap("<CUSTOM_VARIABLE_NAME>", "<CUSTOM_VARIABLE_VALUE>"));

          BulkTriggerEventRequest bulkTriggerEventRequest = new BulkTriggerEventRequest();
          bulkTriggerEventRequest.setEvents(Arrays.asList(triggerEventRequest1, triggerEventRequest2));

          BulkTriggerEventResponse response = novu.bulkTriggerEvent(bulkTriggerEventRequest);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var payload = new List<EventTriggerDataDto>()
  {
      new()
      {
          EventName = "<WORKFLOW_TRIGGER_IDENTIFIER>",
          To = { SubscriberId = "<UNIQUE_SUBSCRIBER_IDENTIFIER>"},
          Payload = new TestRecord(){ Message = "Hello"}
      },
      new()
      {
          EventName = "<WORKFLOW_TRIGGER_IDENTIFIER>",
          To = { SubscriberId = "<UNIQUE_SUBSCRIBER_IDENTIFIER>"},
          Payload = new TestRecord(){ Message = "World"}
      },
  };

  var trigger = await novu.Event.TriggerBulkAsync(payload);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": [
          {
              "acknowledged": true,
              "status": "processed",
              "transactionId": "string"
          }
      ]
  }
  ```
</ResponseExample>


# Cancel triggered event
Source: https://v0.x-docs.novu.co/api-reference/events/cancel-triggered-event

delete /v1/events/trigger/{transactionId}

    Using a previously generated transactionId during the event trigger,
     will cancel any active or pending workflows. This is useful to cancel active digests, delays etc...
    

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<Info> If `false` value is returned in response, it means that event has already been completed its execution or cancelled before. Already completed event can not be cancelled. If `true` value is returned in response, then it means that event execution has been cancelled successfully. Any digest or delay step with pending exection will also be cancelled.</Info>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.events.cancel("transactionId");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $transactionId = "transactionId";

  $novu->cancelEvent($transactionId);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.cancel_triggered_event('transactionId')
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
  	apiKey := "<NOVU_API_KEY>"
  	ctx := context.Background()

  	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

      transactionId := "<transaction_id>";

  	resp, err := novuClient.EventApi.CancelTrigger(ctx, transactionId)

  	if err != nil {
  		log.Fatal("novu error", err.Error())
  		return
  	}
  }
  ```

  ```bash cURL theme={null}

  curl --request DELETE \
    --url https://api.novu.co/v1/events/trigger/<transaction_id> \
    --header 'Authorization: ApiKey <NOVU_API_KEY>'

  ```

  ```python Python theme={null}
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  novu = EventApi(url, api_key).delete("transactionId");
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.events.responses.CancelEventResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);

          String transactionId = "<REPLACE_WITH_TRANSACTION_ID>";

          CancelEventResponse response = novu.cancelTriggeredEvent(transactionId);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var cancelled = await novu.Event.TriggerCancelAsync("triggerTransactionId");
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  { 
    data: true
  }
  ```
</ResponseExample>


# Trigger event
Source: https://v0.x-docs.novu.co/api-reference/events/trigger-event

post /v1/events/trigger

    Trigger event is the main (and only) way to send notifications to subscribers. The trigger identifier is used to match the particular workflow associated with it. Maximum number of recipients can be 100. Additional information can be passed according the body interface below.
    To prevent duplicate triggers, you can optionally pass a **transactionId** in the request body. If the same **transactionId** is used again, the trigger will be ignored. The retention period depends on your billing tier.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
    {
      to: {
        subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
        email: 'john@doemail.com',
        firstName: 'John',
        lastName: 'Doe',
      },
      payload: {
        name: "Hello World",
        organization: {
          logo: 'https://happycorp.com/logo.png',
        },
      },
    }
  );
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->triggerEvent([
      'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
      'payload' => ['customVariables' => 'Hello'],
      'to' => [
          'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          'phone' => '07983882186'
      ]
  ])->toArray();
  ```

  ```bash cURL theme={null}

  curl -X POST https://api.novu.co/v1/events/trigger \
    -H "Authorization: ApiKey <NOVU_API_KEY>" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "<WORKFLOW_TRIGGER_IDENTIFIER>",
      "to": {
        "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
        "email": "john@doemail.com",
        "firstName": "John",
        "lastName": "Doe"
      },
      "payload": {
        "name": "Hello World",
        "organization": {
          "logo": "https://happycorp.com/logo.png"
        }
      }
    }'
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
      'payload' => { # optional
          'first-name' => 'Adam' # optional
      },
      'to' => {
          'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
      },
      'transactionId' => '89kjfke9893' #optional
  }

  client.trigger_event(payload)
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
  	subscriberID := "<UNIQUE_SUBSCRIBER_IDENTIFIER>"
  	apiKey := "<NOVU_API_KEY>"
  	eventId := "<WORKFLOW_TRIGGER_IDENTIFIER>"

  	ctx := context.Background()
  	to := map[string]interface{}{
  		"lastName":     "Doe",
  		"firstName":    "John",
  		"subscriberId": subscriberID,
  		"email":        "john@doemail.com",
  	}

  	payload := map[string]interface{}{
  		"name": "Hello World",
  		"organization": map[string]interface{}{
  			"logo": "https://happycorp.com/logo.png",
  		},
  	}

  	data := novu.ITriggerPayloadOptions{To: to, Payload: payload}
  	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

  	resp, err := novuClient.EventApi.Trigger(ctx, eventId, data)

  	if err != nil {
  		log.Fatal("novu error", err.Error())
  		return
  	}
  }
  ```

  ```python Python theme={null}
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  novu = EventApi(url, api_key).trigger(
      name="<WORKFLOW_TRIGGER_IDENTIFIER>",  # This is the Workflow ID. It can be found on the workflow page.
      recipients="<UNIQUE_SUBSCRIBER_IDENTIFIER>", # The subscriber ID can be gotten from the dashboard.
      payload={},  # Your custom Novu payload goes here
  )
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.events.requests.TriggerEventRequest;
  import co.novu.api.events.responses.TriggerEventResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest = new SubscriberRequest();
          subscriberRequest.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest.setFirstName("<FIRST_NAME>");
          subscriberRequest.setLastName("<LAST_NAME>");
          subscriberRequest.setPhone("<PHONE_NUMBER>");
          subscriberRequest.setAvatar("<AVATAR>");
          subscriberRequest.setSubscriberId("<SUBSCRIBER_ID>");

          TriggerEventRequest triggerEventRequest = new TriggerEventRequest();
          triggerEventRequest.setName("<NAME>");
          triggerEventRequest.setTo(subscriberRequest);
          triggerEventRequest.setPayload(Collections.singletonMap("<CUSTOM_VARIABLE_NAME>", "<CUSTOM_VARIABLE_VALUE>"));
          
          TriggerEventResponse response = novu.triggerEvent(triggerEventRequest);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  public class OnboardEventPayload
  {
    [JsonProperty("username")]
    public string Username { get; set; }

    [JsonProperty("welcomeMessage")]
    public string WelcomeMessage { get; set; }
  }

  var onboardingMessage = new OnboardEventPayload
  {
    Username = "jdoe",
    WelcomeMessage = "Welcome to novu-dotnet"
  };

  var payload = new EventTriggerDataDto()
  {
    EventName = "onboarding",
    To = { SubscriberId = "subscriberId" },
    Payload = onboardingMessage
  };

  var trigger = await novu.Event.Trigger(payload);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "acknowledged": true,
          "status": "processed",
          "transactionId": "string"
      }
  }
  ```
</ResponseExample>

<Accordion title="Idempotent nature of transactionId">
  The `transactionId` within Novu is a unique identifier that is used to ensure the idempotent nature of notification delivery.

  When you trigger an event to send a notification, you have the option to provide a `transactionId`. If you do not provide one, Novu will generate a UUID for you.

  **This identifier is particularly useful for preventing the same notification from being sent multiple times in case the trigger event is inadvertently called more than once.**

  By leveraging the `transactionId`, you can make idempotent requests, which means if the same `transactionId` is used in another request, Novu's API will recognize it and will not send the same notification again.

  <Note>
    This upholds the principle of idempotency, ensuring that the effect of the operation is the same, no matter how many times the request is repeated with the same `transactionId`.
  </Note>
</Accordion>


# Validate the mx record setup for the inbound parse functionality
Source: https://v0.x-docs.novu.co/api-reference/inbound-parse/validate-the-mx-record-setup-for-the-inbound-parse-functionality

get /v1/inbound-parse/mx/status

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import fetch from 'node-fetch';

  const response = await fetch('https://api.novu.co/v1/inbound-parse/mx/status', {
    method: 'GET',
    
  });
  const data = await response.json();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);


  // Validate MX Record for Inbound Parse
  $novu->validateMXRecordForInboundParse()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.validate_mx_record_setup_for_inbound_parse()
  ```

  ```python Python theme={null}
  from novu.api import InboundParseApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = InboundParseApi(url, api_key).validate_mx_record_setup(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.validateMxRecordSetupForInboundParse();
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
      "mxRecordConfigured": true
    }
  }
  ```
</ResponseExample>


# Create an integration
Source: https://v0.x-docs.novu.co/api-reference/integrations/create-integration

post /v1/integrations
Create an integration for the current environment the user is based on the API key provided. 
    Each provider supports different credentials, check the provider documentation for more details. Only integration metadata is returned, credentials field is returned as an empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --location 'https://api.novu.co/v1/integrations' \
  --header 'Content-Type: application/json' \
  --header 'Accept: application/json' \
  --header 'Authorization: ApiKey <NOVU_API_KEY>' \
  --data '{
      "name": "SES",
      "identifier": "ses-NkIQ5Koy3-123",
      "credentials": {
          "apiKey": "ACCESS_KEY_ID",
          "secretKey": "SECRET_ACCESS_KEY",
          "region": "us-east-2",
          "from": "FROM_EMAIL_ADDRESS",
          "senderName": "SENDER_NAME",
          // ... other credentials as per provider
      },
      "conditions": [],
      "active": true,
      "check": false,
      "providerId": "ses",
      "channel": "email"
  }'
  ```

  ```javascript Node.js theme={null}
  import { Novu, ChannelTypeEnum, ProvidersIdEnum } from '@novu/node';  
  const novu = new Novu('<NOVU_API_KEY>');

  const createPaylod = {
    name: "SendGrid",
    identifier: "sendgrid-identifier",
    credentials: {
      apiKey: "SUPER_SECRET_API_KEY",
      from: "sales@novu.co",
      senderName: "Novu Sales Team",
      channel: ChannelTypeEnum.EMAIL,
      // ... other credentials as per provider
    },
    active: true,
    check: false
  }

  await novu.integrations.create(ProvidersIdEnum.SendGrid, createPayload);
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  // Create integration
  $novu->createIntegration([
      'providerId' => '<insert->provider->id>',
      'channel' => '<insert->channel>',
      'credentials' => [
          // insert all the fields
      ],
      'active' => true,
      'check' => true
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  body = {
      'providerId' => '<insert-provider-id>',
      'channel' => '<insert-channel>',
      'credentials' => {
          # insert all the fields
      },
      'active' => true,
      'check' => true
  }
  client.create_integration(body)
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).create(
      integration="", # Integration instance that you want to create.
      check="", # If you want the Novu server to check his connection using given integration configuration. Defaults to True.

  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.createIntegration(body)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "_environmentId": "string",
      "_organizationId": "string",
      "name": "string",
      "identifier": "string",
      "providerId": "string",
      "channel": "in_app",
      "credentials": {
        "apiKey": "string",
        "user": "string",
        "secretKey": "string",
        "domain": "string",
        "password": "string",
        "host": "string",
        "port": "string",
        "secure": true,
        "region": "string",
        "accountSid": "string",
        "messageProfileId": "string",
        "token": "string",
        "from": "string",
        "senderName": "string",
        "projectName": "string",
        "applicationId": "string",
        "clientId": "string",
        "requireTls": true,
        "ignoreTls": true,
        "tlsOptions": {},
        "baseUrl": "string",
        "webhookUrl": "string",
        "redirectUrl": "string",
        "hmac": true,
        "serviceAccount": "string",
        "ipPoolName": "string"
      },
      "active": true,
      "deleted": true,
      "deletedAt": "string",
      "deletedBy": "string",
      "primary": true
    }
  }
  ```
</ResponseExample>


# Delete an integration
Source: https://v0.x-docs.novu.co/api-reference/integrations/delete-integration

delete /v1/integrations/{integrationId}
Delete an integration by its unique key identifier **integrationId**. 
    This action is irreversible. Only integration metadata is returned, credentials field is returned as empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';  

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.integrations.delete("integrationId");
  ```

  ```php PHP theme={null}
  // Get integrations
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');
  $novu->deleteIntegration($integrationId);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.delete_integration('<insert-provider-id>')
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).delete(
      integration_id="<The integration ID>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.deleteIntegration(integrationId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "name": "string",
        "identifier": "string",
        "providerId": "string",
        "channel": "in_app",
        "credentials": {
          "apiKey": "string",
          "user": "string",
          "secretKey": "string",
          "domain": "string",
          "password": "string",
          "host": "string",
          "port": "string",
          "secure": true,
          "region": "string",
          "accountSid": "string",
          "messageProfileId": "string",
          "token": "string",
          "from": "string",
          "senderName": "string",
          "projectName": "string",
          "applicationId": "string",
          "clientId": "string",
          "requireTls": true,
          "ignoreTls": true,
          "tlsOptions": {},
          "baseUrl": "string",
          "webhookUrl": "string",
          "redirectUrl": "string",
          "hmac": true,
          "serviceAccount": "string",
          "ipPoolName": "string"
        },
        "active": true,
        "deleted": true,
        "deletedAt": "string",
        "deletedBy": "string",
        "primary": true
      }
    ]
  }
  ```
</ResponseExample>


# List active integrations
Source: https://v0.x-docs.novu.co/api-reference/integrations/get-active-integrations

get /v1/integrations/active
List all the active integrations created in the organization. Only integration metadata is returned, credentials field is returned as an empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node'; 

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.integrations.getActive();
  ```

  ```php PHP theme={null}
  // Get integrations
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getActiveIntegrations()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.active_integrations()
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).list(
      only_active=true # This allows one to retrieve only active integrations. Defaults to False.
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.activeIntegrations()
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```
  {
      _id: "_id",
      _environmentId: "_environmentId",
      _organizationId: "_organizationId",
      name: "name",
      identifier: "identifier",
      providerId: "providerId",
      channel: "channel",
      credentials: credentials,
      active: true,
      deleted: true,
      deletedAt: "deletedAt",
      deletedBy: "deletedBy",
      primary: true
  }
  ```
</ResponseExample>


# List all integrations
Source: https://v0.x-docs.novu.co/api-reference/integrations/get-integrations

get /v1/integrations
List all the channels integrations created in the organization. Only integration metadata is returned, credentials field is returned as an empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';  

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.integrations.getAll();
  ```

  ```php PHP theme={null}
  // Get integrations
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getIntegrations()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.integrations()
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
      // get integrations
  	integrations, err := novuClient.IntegrationsApi.GetAll(ctx)
  	if err != nil {
  		log.Fatal("Get all integrations error: ", err.Error())
  	}
  	fmt.Println(integrations)
  }
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).list(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.integrations()
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      _id: "_id",
      _environmentId: "_environmentId",
      _organizationId: "_organizationId",
      name: "name",
      identifier: "identifier",
      providerId: "providerId",
      channel: "channel",
      credentials: credentials,
      active: true,
      deleted: true,
      deletedAt: "deletedAt",
      deletedBy: "deletedBy",
      primary: true
  }
  ```
</ResponseExample>


# Get webhook support status for provider
Source: https://v0.x-docs.novu.co/api-reference/integrations/get-webhook-support-status-for-provider

get /v1/integrations/webhook/provider/{providerId}/status

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu, ProvidersIdEnum } from '@novu/node';  

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.integrations.getWebhookProviderStatus(ProvidersIdEnum.SendGrid);
  ```

  ```php PHP theme={null}
  // Get integrations
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getWebhookSupportStatusForProvider($providerId)->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.webhook_provider_status('<insert-provider-id>')
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).status(
      provider_id="<The_Provider_ID>", # Get webhook support status for a given provider using its providerID.
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.webhookProviderStatus(providerId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      200: "The status of the webhook for the provider requested"
  }
  ```
</ResponseExample>


# Update integration as primary
Source: https://v0.x-docs.novu.co/api-reference/integrations/set-integration-as-primary

post /v1/integrations/{integrationId}/set-primary
Update an integration as **primary** by its unique key identifier **integrationId**. 
    This API will set the integration as primary for that channel in the current environment. 
    Primary integration is used to deliver notification for sms and email channels in the workflow. 
    Only integration metadata is returned, credentials field is returned as an empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';  

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.integrations.setIntegrationAsPrimary("integrationId")
  ```

  ```php PHP theme={null}
  <?php

  $url = 'https://api.novu.co/v1/integrations/:integrationId/set-primary';
  $data = array(
    [options]
  );
  $options = array(
    "http" => array(
    "header"  => "Content-type: application/json",
    "header"  => "Authorization: ApiKey REPLACE_WITH_API_KEY",
    "method"  => "POST",
    "content" => json_encode($data)
    )
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);

  if ($result === FALSE) { /* Handle error */ }

  echo $result;
      
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'uri'

  uri = URI.parse('https://api.novu.co/v1/integrations/:integrationId/set-primary')
  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri)

  request.body = '{
    [options]
  }'
  request.content_type = 'application/json'
  request.add_field('Authorization', 'ApiKey REPLACE_WITH_API_KEY')


  response = http.request(request)

  puts response.body
      
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/integrations/:integrationId/set-primary"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
  ```

  ```python Python theme={null}
  import requests

  response = requests.post('https://api.novu.co/v1/integrations/:integrationId/set-primary')

  print(response.json())
      
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "_id": "string",
    "_environmentId": "string",
    "_organizationId": "string",
    "name": "string",
    "identifier": "string",
    "providerId": "string",
    "channel": "in_app",
    "credentials": {
      "apiKey": "string",
      "user": "string",
      "secretKey": "string",
      "domain": "string",
      "password": "string",
      "host": "string",
      "port": "string",
      "secure": true,
      "region": "string",
      "accountSid": "string",
      "messageProfileId": "string",
      "token": "string",
      "from": "string",
      "senderName": "string",
      "projectName": "string",
      "applicationId": "string",
      "clientId": "string",
      "requireTls": true,
      "ignoreTls": true,
      "tlsOptions": {},
      "baseUrl": "string",
      "webhookUrl": "string",
      "redirectUrl": "string",
      "hmac": true,
      "serviceAccount": "string",
      "ipPoolName": "string"
    },
    "active": true,
    "deleted": true,
    "deletedAt": "string",
    "deletedBy": "string",
    "primary": true
  }
  ```
</ResponseExample>


# Update an integration
Source: https://v0.x-docs.novu.co/api-reference/integrations/update-integration

put /v1/integrations/{integrationId}
Update an integration by its unique key identifier **integrationId**. 
    Each provider supports different credentials, check the provider documentation for more details. Only integration metadata is returned, credentials field is returned as an empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu, ProvidersIdEnum } from '@novu/node'; 

  const novu = new Novu('<NOVU_API_KEY>');

  const updatePayload = {
    name: "SendGrid",
    identifier: "sendgrid-identifier",
    credentials: {
      apiKey: "SUPER_SECRET_API_KEY",
      from: "no-reply@novu.co",
      senderName: "Novu Team"
      // ... other credentials as per provider
    },
    active: true,
    check: false
  }

  await novu.integrations.getWebhookProviderStatus(ProvidersIdEnum.SendGrid, updatePayload);
  ```

  ```php PHP theme={null}
  // Get integrations
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->updateIntegration($integrationId, [
      'active' => true,
      'credentials' => [
          // insert all the fields
      ],
      'check' => true
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  body = {
      'active' => true,
      'check' => true
      'credentials' => {
          # insert all the fields
      },
  }
  client.update_integration('<insert-provider-id>', body)
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).update(
      integration="<The instance of the integration to update>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.updateIntegration(integrationId, body);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "_environmentId": "string",
      "_organizationId": "string",
      "name": "string",
      "identifier": "string",
      "providerId": "string",
      "channel": "in_app",
      "credentials": {
        "apiKey": "string",
        "user": "string",
        "secretKey": "string",
        "domain": "string",
        "password": "string",
        "host": "string",
        "port": "string",
        "secure": true,
        "region": "string",
        "accountSid": "string",
        "messageProfileId": "string",
        "token": "string",
        "from": "string",
        "senderName": "string",
        "projectName": "string",
        "applicationId": "string",
        "clientId": "string",
        "requireTls": true,
        "ignoreTls": true,
        "tlsOptions": {},
        "baseUrl": "string",
        "webhookUrl": "string",
        "redirectUrl": "string",
        "hmac": true,
        "serviceAccount": "string",
        "ipPoolName": "string"
      },
      "active": true,
      "deleted": true,
      "deletedAt": "string",
      "deletedBy": "string",
      "primary": true
    }
  }
  ```
</ResponseExample>


# Delete layout
Source: https://v0.x-docs.novu.co/api-reference/layouts/delete-layout

delete /v1/layouts/{layoutId}
Execute a soft delete of a layout given a certain ID.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.layouts.delete("layoutId");
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.delete_layout('<insert-layout-id>')
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).delete(
      layout_id="<Layout_ID to identify the layout to be deleted>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.deleteLayout(layoutId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      204: "The layout has been deleted correctly",
      404: "The layout with the layoutId provided does not exist in the database so it can not be deleted.",
      409: "Either you are trying to delete a layout that is being used or a layout that is the default in the environment."
  }
  ```
</ResponseExample>


# Filter layouts
Source: https://v0.x-docs.novu.co/api-reference/layouts/filter-layouts

get /v1/layouts
Returns a list of layouts that can be paginated using the `page` query parameter and filtered by the environment where it is executed from the organization the user belongs to.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  const params = {
    page: 0, // optional
    pageSize: 20, // optional
    sortBy: "_id"
    orderBy: -1 //optional
  }

  await novu.layouts.list(params);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.layouts({
      'page' => 1, # optional
      'pageSize' => 10, # optional
      'sortBy' => 'createdAt', # optional
      'orderBy' => 1 # optional
  })
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).list(
      page="<Page number for pagination>",
      limit="Size of each page",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.layouts(query = {});
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      data: ["data"],
      page: 0,
      pageSize: 0,
      totalCount: 0
  }
  ```
</ResponseExample>


# Get layout
Source: https://v0.x-docs.novu.co/api-reference/layouts/get-layout

get /v1/layouts/{layoutId}
Get a layout by its ID

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.layouts.get("layoutId");
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  body = {
      'active' => true,
      'check' => true
      'credentials' => {
          # insert all the fields
      },
  }
  client.layout('<insert-layout-id>')
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).get(
      layout_id="<The layout ID>"
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.layout(layoutId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "_organizationId": "string",
      "_environmentId": "string",
      "_creatorId": "string",
      "name": "string",
      "identifier": "string",
      "description": "string",
      "channel": "in_app",
      "content": "string",
      "contentType": "string",
      "variables": [
        {}
      ],
      "isDefault": true,
      "isDeleted": true,
      "createdAt": "string",
      "updatedAt": "string",
      "_parentId": "string"
    }
  }
  ```
</ResponseExample>


# Layout creation
Source: https://v0.x-docs.novu.co/api-reference/layouts/layout-creation

post /v1/layouts
Create a layout

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  const payload = {
    content: "<h1>Layout Start</h1>{{{body}}}<h1>Layout End</h1>",
    description: "Organisation's first layout",
    name: "First Layout",
    identifier: "firstlayout",
    variables: [
      {
        type: "String",
        name: "body"
        required: true
        defValue: ""
      }
    ]
    isDefault: "false"
  }
  await novu.layouts.create(payload);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  payload = {
      'name' => 'New layout',
      'content' => '{{{body}}}',
      'variables' => ['<list-variables-here>'], # optional
      'description' => 'This is a description for the new layout', # optional
      'isDefault' => true # optional
  }
  client.create_layout(payload)
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).create(
      layout="<The instance of the layout to create>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.createLayout(body);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
      "_id": "Layout identifier"
    }
  }
  ```
</ResponseExample>


# Set default layout
Source: https://v0.x-docs.novu.co/api-reference/layouts/set-default-layout

post /v1/layouts/{layoutId}/default
Sets the default layout for the environment and updates to non default to the existing default layout (if any).

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.layouts.setDefault("layoutId");
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.make_default_layout('<insert-layout-id>')
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).set_default(
      layout_id= "<The layout_id corresponding to the layout to be set default>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.makeDefaultLayout(layoutId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      204: "The selected layout has been set as the default for the environment."

      404: "The layout with the layoutId provided does not exist in the database so it can not be set as the default for the environment."
  }
  ```
</ResponseExample>


# Update a layout
Source: https://v0.x-docs.novu.co/api-reference/layouts/update-a-layout

patch /v1/layouts/{layoutId}
Update the name, content and variables of a layout. Also change it to be default or no.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  const payloadToUpdate = {
    content: "<h1>Layout Start</h1>{{{body}}}<h1>Layout End</h1>",
    description: "Organisation's first layout",
    name: "First Layout",
    identifier: "firstlayout",
    variables: [
      {
        type: "String",
        name: "body"
        required: true
        defValue: ""
      }
    ]
    isDefault: false
  }
  await novu.layouts.update("layoutId", payloadToUpdate);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  payload = {
      'name' => 'Update layout', # optional
      'content' => '{{{body}}}', # optional
      'description' => 'This is a description for the new layout', # optional
      'isDefault' => true # optional
      'variables' => ['<list-variables-here>'], # optional
  }
  client.update_layout('<insert-layout-id>', payload)
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).patch(
      layout= "<The instance of the layout to be updated>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.updateLayout(layoutId, body);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "name": "string",
    "identifier": "string",
    "description": "string",
    "content": "string",
    "variables": [
      {}
    ],
    "isDefault": true
  }
  ```
</ResponseExample>


# Retrieve an event
Source: https://v0.x-docs.novu.co/api-reference/notification/get-notification

get /v1/notifications/{notificationId}
Retrieve an event by its unique key identifier **notificationId**. 
    Here **notificationId** is of mongodbId type. 
    This API returns the event details - execution logs, status, actual notification (message) generated by each workflow step.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.notification

  fun main() {
      val novu = Novu(apiKey = "<NOVU_API_KEY>")
      val notification = novu.notification("<NOTIFICATION_ID>")
      println(notification)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notifications/{notificationId} \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```python Python theme={null}
  from novu.api import NotificationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  notificationApi = NotificationApi(url, api_key)

  notification = notificationApi.get("<notificationId>")
  print(notification)
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $notification = $novu->getNotification($notificationId)-toArray();
  ```
</RequestExample>


# Get notification graph statistics
Source: https://v0.x-docs.novu.co/api-reference/notification/get-notification-graph-statistics

get /v1/notifications/graph/stats

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notifications/graph/stats \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```python Python theme={null}
  from novu.api import NotificationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  notificationApi = NotificationApi(url, api_key)

  graphStats = notificationApi.graph_stats()
  list(graphStats)
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $notificationGraphStats = $novu->getNotificationGraphStats()->toArray();
  ```
</RequestExample>


# Get notification statistics
Source: https://v0.x-docs.novu.co/api-reference/notification/get-notification-statistics

get /v1/notifications/stats

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.notificationsStats

  fun main() {
      val novu = Novu(apiKey = "<NOVU_API_KEY>")
      val notificationsStats = novu.notificationsStats()
      println(notificationsStats)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notifications/stats \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```python Python theme={null}
  from novu.api import NotificationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  notificationApi = NotificationApi(url, api_key)

  notification_stats = notificationApi.stats()
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $notificationStats = $novu->getNotificationStats()->toArray();
  ```
</RequestExample>


# List all events
Source: https://v0.x-docs.novu.co/api-reference/notification/get-notifications

get /v1/notifications
List all notification events (triggered events) for the current environment. 
    This API supports filtering by **channels**, **templates**, **emails**, **subscriberIds**, **transactionId**, **topicKey**, **severity**, **contextKeys**. 
    Checkout all available filters in the query section.
    This API returns event triggers, to list each channel notifications, check messages APIs.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.dto.request.NotificationRequest
  import co.novu.extensions.notifications

  fun main() {
      val novu = Novu(apiKey = "<NOVU_API_KEY>")
      val notificationRequest = NotificationRequest("<CHANNELS>", "<TEMPLATES>", "<EMAILS>", "<SEARCH>");
      val notifications = novu.notifications(notificationRequest)
      println(notifications)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notifications \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```python Python theme={null}
  from novu.api import NotificationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  notificationApi = NotificationApi(url, api_key)

  notifications = notificationApi.list()
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $notifications = $novu->getNotifications()->toArray();
  ```
</RequestExample>


# API Overview
Source: https://v0.x-docs.novu.co/api-reference/overview

In this page you can learn about how to work with Novu's API

<Note>
  It's important to note that our API and backend SDK are intended for use
  exclusively in server-side applications. **Attempting to use them in a
  client-side application will result in Cross-Origin Resource Sharing (CORS)
  errors.** This restriction ensures the security and integrity of our services.
</Note>

## Authentication

Authentication for the Novu API involves the use of an API Key, which is a secure credential that is tied to your Novu account. This key should be included in the header of the request in the Authorization field as a string prefixed with 'ApiKey '.

```curl theme={null}
--header 'Authorization: ApiKey <NOVU_API_KEY>'
```

For example, when using Novu in a Node.js application, the Novu package should be imported and initialized with the API key, as shown in this snippet:

```javascript theme={null}
import { Novu } from "@novu/node";
const novu = new Novu("<NOVU_API_KEY>");
```

Replace `<NOVU_API_KEY>` with your actual API Key, available in the API Key section of the Novu Dashboard.

<Warning>
  It is advised not to hardcode your credentials in a file in production
  environments. Use environment variables instead.
</Warning>

## API Endpoints

Novu provides a multitude of API endpoints that enable a variety of functionalities.
the base URL for the Novu API is `https://api.novu.co/v1`.

<Note>
  We offer two API options: the US API and the EU API. By default, our API documentation refers to the US API, which can be accessed at: [https://api.novu.co/v1](https://api.novu.co/v1).

  If you require the EU version, you can access it here: [https://eu.api.novu.co/v1](https://eu.api.novu.co/v1).
</Note>

For instance, to get tenant information, the endpoint to use would include the tenant's identifier and look like this `https://api.novu.co/v1/tenants/{identifier}`.


# API Rate Limiting
Source: https://v0.x-docs.novu.co/api-reference/rate-limiting

In this page you can learn about how rate limiting works with Novu's API

<Note>
  This feature is available from v0.22.0.
</Note>

Rate limiting is an essential functionality for establishing a robust and resilient system. It safeguards system resources from being misused by malicious actors or being monopolized by one client.

A variable-cost token bucket rate limited algorithm has been added to provide the capability for different API controllers and methods to have a varying cost. It also lays a foundation for dynamic costing of resource consumption.

## Limits

The following limits apply to each category of the Novu system. Each category has an independent bucket of rate-limit tokens to consume.
Bulk requests have a rate limit cost of 100 times the base limit and consume from the same token pool. For example, the free tier would allow a combined maximum of 10 standard trigger events and 2 bulk trigger events in the same 1-second window.

| Category      | Free   | Business | Endpoints                                                            |
| ------------- | ------ | -------- | -------------------------------------------------------------------- |
| Events        | 60 rps | 600 rps  | Trigger                                                              |
| Configuration | 15 rps | 150 rps  | Subscribers, Topics, Tenants                                         |
| Global        | 30 rps | 300 rps  | All other endpoints consume rate limiting tokens from this category. |


# Bulk create subscribers
Source: https://v0.x-docs.novu.co/api-reference/subscribers/bulk-create-subscribers

post /v1/subscribers/bulk

      Using this endpoint multiple subscribers can be created at once. The bulk API is limited to 500 subscribers per request.
    

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.subscribers.bulkCreate([
      {
          subscriberId: 'test-subscriber-1',
          email: 'test-user@sd.com',
          firstName: 'subscriber-1',
          lastName: 'test-1',
      },
      {
          subscriberId: 'test-subscriber-2',
          email: 'test-user-2@sd.com',
          firstName: 'subscriber-2',
          lastName: 'test-2',
      },
      {
          subscriberId: 'test-subscriber-3',
      },
  ]);
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.subscribers.responses.CreateBulkSubscriberResponse;
  import co.novu.api.subscribers.requests.BulkSubscriberRequest;

  public class Main {
     public static void main(String[] args) {

          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest1 = new SubscriberRequest();
          subscriberRequest1.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest1.setFirstName("<FIRST_NAME>");
          subscriberRequest1.setLastName("<LAST_NAME>");
          subscriberRequest1.setPhone("<PHONE_NUMBER>");
          subscriberRequest1.setAvatar("<AVATAR>");
          subscriberRequest1.setSubscriberId("<SUBSCRIBER_ID>");

          SubscriberRequest subscriberRequest2 = new SubscriberRequest();
          subscriberRequest2.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest2.setFirstName("<FIRST_NAME>");
          subscriberRequest2.setLastName("<LAST_NAME>");
          subscriberRequest2.setPhone("<PHONE_NUMBER>");
          subscriberRequest2.setAvatar("<AVATAR>");
          subscriberRequest2.setSubscriberId("<SUBSCRIBER_ID>");

          BulkSubscriberRequest bulkSubscriberRequest = new BulkSubscriberRequest();
          bulkSubscriberRequest.setSubscribers(Arrays.asList(subscriberRequest1, subscriberRequest2));

          CreateBulkSubscriberResponse response = novu.createSubscriberBulk(bulkSubscriberRequest);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "updated": [],
          "created": [
          {
              "subscriberId": "test-subscriber-1"
          },
          {
              "subscriberId": "test-subscriber-2"
          },
          {
              "subscriberId": "test-subscriber-3"
          }
          ],
          "failed": []
      }
  }
  ```
</ResponseExample>


# Create subscriber
Source: https://v0.x-docs.novu.co/api-reference/subscribers/create-subscriber

post /v1/subscribers
Creates a subscriber entity, in the Novu platform. The subscriber will be later used to receive notifications, and access notification feeds. Communication credentials such as email, phone number, and 3 rd party credentials i.e slack tokens could be later associated to this entity.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --location 'https://api.novu.co/v1/subscribers' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <NOVU_API_KEY>' \
    --data-raw '{
      "firstName": "Pawan",
      "lastName": "Jain",
      "email": "pawan.jain@domain.com",
      "phone": "+1234567890",
      "avatar": "avatar-url",
      "locale": "en-US",
      "data": {
        "isDeveloper": true,
        "customKey": "customValue"
        }
      }'
  ```

  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.subscribers.identify("subscriberId", {
    firstName: "Pawan",
    lastName: "Jain",
    email: "pawan.jain@domain.com",
    phone: "+1234567890",
    avatar: "https://gravatar.com/avatar/553b157d82ac2880237566d5a644e5fe?s=400&d=robohash&r=x",
    locale: "en-US",
    data: {
      isDeveloper: true,
      customKey: "customValue"
    }
  });
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $novu->createSubscriber([
      'subscriberId' => 'YOUR_SYSTEM_USER_ID>',
      'email' => '<insert-email>', // optional
      'firstName' => '<insert-firstname>', // optional
      'lastName' => '<insert-lastname>', // optional
      'phone' => '<insert-phone>', //optional
      'avatar' => '<insert-avatar>', // optional
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'subscriberId' => '7789',
      'email' => '<insert-email>', # optional
      'firstName' => '<insert-firstName>', # optional
      'lastName' => '<insert-lastName>', # optional
      'phone' => '<insert-phone>', # optional
      'avatar' => '<insert-profile-avatar>' # optional
  }
  client.create_subscriber(payload)
  ```

  ```python Python theme={null}
  from novu.dto.subscriber import SubscriberDto
  from novu.api.subscriber import SubscriberApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  # Define a subscriber instance
  subscriber = SubscriberDto(
      email="novu_user@mail.com",
      subscriber_id="82a48af6ac82b3cc2157b57f", #This is what the subscriber_id looks like
      first_name="",  # Optional
      last_name="",  # Optional
      phone="",  # Optional
      avatar="",  # Optional
  )

  # Create a subscriber
  novu = SubscriberApi(url, api_key).create(subscriber)
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.subscribers.responses.CreateSubscriberResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest = new SubscriberRequest();
          subscriberRequest.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest.setFirstName("<FIRST_NAME>");
          subscriberRequest.setLastName("<LAST_NAME>");
          subscriberRequest.setPhone("<PHONE_NUMBER>");
          subscriberRequest.setAvatar("<AVATAR>");
          subscriberRequest.setSubscriberId("<SUBSCRIBER_ID>");

          CreateSubscriberResponse response = novu.createSubscriber(subscriberRequest);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var additionalData = new List<AdditionalDataDto>
  {
    new AdditionalDataDto
    {
      Key = "External ID",
      Value = "1122334455"
    },
    new AdditionalDataDto
    {
      Key = "SMS_PREFERENCE",
      Value = "EMERGENT_ONLY"
    }
  };

  var newSubscriberDto = new CreateSubscriberDto
  {
    SubscriberId = "unique_subscriber_id",
    FirstName = "John",
    LastName = "Doe",
    Avatar = "https://unslpash.com/random",
    Email = "jdoe@novu.co",
    Locale = "en-US",
    Phone = "+11112223333",
    Data = additionalData
  };

  var subscriber = await novu.Subscriber.CreateSubscriber(newSubscriberDto)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "_organizationId": "abcd12349876wxyz1234wxyz",
          "_environmentId": "zyxw4321abcd1234lmno5678",
          "firstName": "Alex",
          "lastName": "Benjamin",
          "phone": "123456789",
          "subscriberId": "abcd1234",
          "email": "alex@email.com",
          "avatar": "string",
          "locale": "en-US",
          "channels": [],
          "_id": "6516ed5a9d727fe8256028ed",
          "deleted": false,
          "createdAt": "2023-09-29T15:29:30.667Z",
          "updatedAt": "2023-09-29T15:29:30.667Z",
          "__v": 0,
          "id": "6516ed5a9d727fe8256028ed"
      }
  }
  ```
</ResponseExample>


# Delete subscriber
Source: https://v0.x-docs.novu.co/api-reference/subscribers/delete-subscriber

delete /v1/subscribers/{subscriberId}
Deletes a subscriber entity from the Novu platform

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.subscribers.delete("subscriberId");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $novu->deleteSubscriber($subscriberId);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.delete_subscriber('<insert-subscriber-id>')
  ```

  ```python Python theme={null}
  from novu.dto.event import InputEventDto
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  # Delete a subscriber
  novu = SubscriberApi(url, api_key).delete(subscriber_id)
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SubscriberDeleteResponse;

  public class Main {
     public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";

          SubscriberDeleteResponse response = novu.deleteSubscriber(subscriberId);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var deleted = await novu.Subscriber.DeleteSubscriber("subscriberId");
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "acknowledged": true,
          "status": "deleted"
      }
  }
  ```
</ResponseExample>


# Delete provider credentials
Source: https://v0.x-docs.novu.co/api-reference/subscribers/delete-subscriber-credentials-by-providerid

delete /v1/subscribers/{subscriberId}/credentials/{providerId}
Delete subscriber credentials for a provider such as **slack** and **FCM** by **providerId**. 
    This action is irreversible and will remove the credentials for the provider for particular **subscriberId**.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Retrieve subscriber notifications
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-in-app-notification-feed-for-a-particular-subscriber

get /v1/subscribers/{subscriberId}/notifications/feed
This API is deprecated, use v2 API instead. Retrieve subscriber in-app notifications by its unique key identifier **subscriberId**.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SubscriberNotificationResponse;

  public class Main {
     public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";

          SubscriberNotificationResponse response = novu.getSubscriberNotificationsFeed(subscriberId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_environmentId": "string",
        "_feedId": "string",
        "_id": "string",
        "_messageTemplateId": "string",
        "_notificationId": "string",
        "_organizationId": "string",
        "_subscriberId": "string",
        "_templateId": "string",
        "channel": "in_app",
        "createdAt": "string",
        "cta": {
          "action": {
            "buttons": [
              {
                "content": "string",
                "resultContent": "string",
                "type": "primary"
              }
            ],
            "result": {
              "payload": "object",
              "type": "primary"
            },
            "status": "pending"
          },
          "data": {
            "url": "string"
          },
          "type": "redirect"
        },
        "deviceTokens": [
          "string"
        ],
        "directWebhookUrl": "string",
        "email": "string",
        "errorId": "string",
        "errorText": "string",
        "lastSeenDate": "string",
        "overrides": "object",
        "payload": "object",
        "phone": "string",
        "providerId": "string",
        "seen": "boolean",
        "status": "sent",
        "subject": "string",
        "subscriber": {
          "__v": "number",
          "_environmentId": "string",
          "_id": "string",
          "_organizationId": "string",
          "avatar": "string",
          "channels": [
            {
              "_integrationId": "string",
              "credentials": {
                "channel": "string",
                "deviceTokens": [
                  "string"
                ],
                "webhookUrl": "string"
              },
              "integrationIdentifier": "string",
              "providerId": "slack"
            }
          ],
          "createdAt": "string",
          "deleted": "boolean",
          "email": "string",
          "firstName": "string",
          "isOnline": "boolean",
          "lastName": "string",
          "lastOnlineAt": "string",
          "locale": "string",
          "phone": "string",
          "subscriberId": "string",
          "updatedAt": "string"
        },
        "template": {
          "_creatorId": "string",
          "_environmentId": "string",
          "_id": "string",
          "_notificationGroupId": "string",
          "_organizationId": "string",
          "_parentId": "string",
          "active": "boolean",
          "critical": "boolean",
          "data": "object",
          "deleted": "boolean",
          "deletedAt": "string",
          "deletedBy": "string",
          "description": "string",
          "draft": "boolean",
          "name": "string",
          "notificationGroup": {
            "_environmentId": "string",
            "_id": "string",
            "_organizationId": "string",
            "_parentId": "string",
            "name": "string"
          },
          "preferenceSettings": {
            "chat": "boolean",
            "email": "boolean",
            "in_app": "boolean",
            "push": "boolean",
            "sms": "boolean"
          },
          "steps": [
            {
              "_id": "string",
              "_parentId": "object",
              "_templateId": "string",
              "active": "boolean",
              "filters": [
                {
                  "children": [
                    {
                      "field": "string",
                      "operator": "LARGER",
                      "true": "subscriber",
                      "value": "string"
                    }
                  ],
                  "isNegated": "boolean",
                  "type": "BOOLEAN",
                  "value": "AND"
                }
              ],
              "name": "string",
              "replyCallback": "object",
              "shouldStopOnFail": "boolean",
              "template": "object",
              "uuid": "string"
            }
          ],
          "tags": [
            "string"
          ],
          "triggers": [
            {
              "identifier": "string",
              "subscriberVariables": [
                {
                  "name": "string"
                }
              ],
              "type": "string",
              "variables": [
                {
                  "name": "string"
                }
              ]
            }
          ],
          "workflowIntegrationStatus": "object"
        },
        "templateIdentifier": "string",
        "title": "string",
        "transactionId": "string"
      }
    ],
    "hasMore": "boolean",
    "page": "number",
    "pageSize": "number"
  }
  ```
</ResponseExample>


# Get subscriber
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-subscriber

get /v1/subscribers/{subscriberId}
Get subscriber by your internal id used to identify the subscriber

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  const response = await novu.subscribers.get("subscriberId");
  console.log(response.data);
  ```

  ```bash cURL theme={null}
  curl --request GET \
    --url https://api.novu.co/v1/subscribers/{subscriberId} \
    --header 'Authorization: <authorization>'
  ```

  ```python Python theme={null}
  import requests

  url = "https://api.novu.co/v1/subscribers/{subscriberId}"

  headers = {"Authorization": "<authorization>"}

  response = requests.request("GET", url, headers=headers)

  print(response.text)
  ```

  ```javascript JavaScript theme={null}
  const options = {method: 'GET', headers: {Authorization: '<authorization>'}};

  fetch('https://api.novu.co/v1/subscribers/{subscriberId}', options)
    .then(response => response.json())
    .then(response => console.log(response))
    .catch(err => console.error(err));
  ```

  ```php PHP theme={null}
  <?php

  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://api.novu.co/v1/subscribers/{subscriberId}",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
      "Authorization: <authorization>"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://api.novu.co/v1/subscribers/{subscriberId}"

  	req, _ := http.NewRequest("GET", url, nil)

  	req.Header.Add("Authorization", "<authorization>")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SingleSubscriberResponse;

  public class Main {
     public static void main(String[] args) {
        String apiKey = "<NOVU_API_KEY>";
        Novu novu = new Novu(apiKey);
        String subscriberId = "<SUBSCRIBER_ID>";

        SingleSubscriberResponse response = novu.getSubscriber(subscriberId);
    }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "firstName": "string",
      "lastName": "string",
      "email": "string",
      "phone": "string",
      "avatar": "string",
      "locale": "string",
      "subscriberId": "string",
      "channels": [
        {
          "providerId": "slack",
          "integrationIdentifier": "string",
          "credentials": {
            "webhookUrl": "string",
            "channel": "string",
            "deviceTokens": [
              "string"
            ]
          },
          "_integrationId": "string"
        }
      ],
      "isOnline": "boolean",
      "lastOnlineAt": "string",
      "_organizationId": "string",
      "_environmentId": "string",
      "deleted": "boolean",
      "createdAt": "string",
      "updatedAt": "string",
      "__v": "number"
    }
  }
  ```
</ResponseExample>


# Get subscriber global preferences
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-subscriber-global-preferences

get /v1/subscribers/{subscriberId}/preferences/{level}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get subscriber preferences
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-subscriber-preferences

get /v1/subscribers/{subscriberId}/preferences

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SubscriberPreferenceResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";

          SubscriberPreferenceResponse response = novu.getSubscriberPreferences(subscriberId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "preference": {
          "channels": {
            "chat": "boolean",
            "email": "boolean",
            "in_app": "boolean",
            "push": "boolean",
            "sms": "boolean"
          },
          "enabled": "boolean"
        },
        "template": {
          "_id": "string",
          "critical": "boolean",
          "name": "string"
        }
      }
    ]
  }
  ```
</ResponseExample>


# Get subscribers
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-subscribers

get /v1/subscribers
Returns a list of subscribers, could paginated using the `page` and `limit` query parameter

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.BulkSubscriberResponse;

  public class Main {
     public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);

          Integer page = 0;
          Integer limit = 10;

          BulkSubscriberResponse response = novu.getSubscribers(page, limit);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "__v": "number",
        "_environmentId": "string",
        "_id": "string",
        "_organizationId": "string",
        "avatar": "string",
        "channels": [
          {
            "_integrationId": "string",
            "credentials": {
              "channel": "string",
              "deviceTokens": [
                "string"
              ],
              "webhookUrl": "string"
            },
            "integrationIdentifier": "string",
            "providerId": "slack"
          }
        ],
        "createdAt": "string",
        "deleted": "boolean",
        "email": "string",
        "firstName": "string",
        "isOnline": "boolean",
        "lastName": "string",
        "lastOnlineAt": "string",
        "locale": "string",
        "phone": "string",
        "subscriberId": "string",
        "updatedAt": "string"
      }
    ],
    "hasMore": "boolean",
    "page": "number",
    "pageSize": "number"
  }
  ```
</ResponseExample>


# Retrieve unseen notifications count
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-the-unseen-in-app-notifications-count-for-subscribers-feed

get /v1/subscribers/{subscriberId}/notifications/unseen
This API is deprecated, use v2 API instead. Retrieve unseen in-app notifications count for a subscriber by its unique key identifier **subscriberId**.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Handle chat oauth
Source: https://v0.x-docs.novu.co/api-reference/subscribers/handle-chat-oauth

get /v1/subscribers/{subscriberId}/credentials/{providerId}/oauth

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Handle providers oauth redirect
Source: https://v0.x-docs.novu.co/api-reference/subscribers/handle-providers-oauth-redirect

get /v1/subscribers/{subscriberId}/credentials/{providerId}/oauth/callback

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Mark a subscriber feed message as seen
Source: https://v0.x-docs.novu.co/api-reference/subscribers/mark-a-subscriber-feed-message-as-seen

post /v1/subscribers/{subscriberId}/messages/markAs

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update notification action status
Source: https://v0.x-docs.novu.co/api-reference/subscribers/mark-message-action-as-seen

post /v1/subscribers/{subscriberId}/messages/{messageId}/actions/{type}
This API is deprecated, use v2 API instead. Update in-app notification's action status by its unique key identifier **messageId** and type field **type**. 
      **type** field can be **primary** or **secondary**

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update all notifications state
Source: https://v0.x-docs.novu.co/api-reference/subscribers/marks-all-the-subscriber-messages-as-read-unread-seen-or-unseen-optionally-you-can-pass-feed-id-or-array-to-mark-messages-of-a-particular-feed

post /v1/subscribers/{subscriberId}/messages/mark-all
This API is deprecated, use v2 API instead. Update all subscriber in-app notifications state such as read, unread, seen or unseen by **subscriberId**.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update subscriber
Source: https://v0.x-docs.novu.co/api-reference/subscribers/update-subscriber

put /v1/subscribers/{subscriberId}
Used to update the subscriber entity with new information

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SingleSubscriberResponse;
  import co.novu.api.subscribers.requests.UpdateSubscriberRequest;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";

          UpdateSubscriberRequest updateSubscriberRequest = new UpdateSubscriberRequest();
          updateSubscriberRequest.setEmail("<EMAIL_ADDRESS>");
          updateSubscriberRequest.setFirstName("<FIRST_NAME>");
          updateSubscriberRequest.setLastName("<LAST_NAME>");
          updateSubscriberRequest.setPhone("<PHONE_NUMBER>");


          SingleSubscriberResponse response = novu.updateSubscriber(updateSubscriberRequest, subscriberId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "__v": "number",
      "_environmentId": "string",
      "_id": "string",
      "_organizationId": "string",
      "avatar": "string",
      "channels": [
        {
          "_integrationId": "string",
          "credentials": {
            "channel": "string",
            "deviceTokens": [
              "string"
            ],
            "webhookUrl": "string"
          },
          "integrationIdentifier": "string",
          "providerId": "slack"
        }
      ],
      "createdAt": "string",
      "deleted": "boolean",
      "email": "string",
      "firstName": "string",
      "isOnline": "boolean",
      "lastName": "string",
      "lastOnlineAt": "string",
      "locale": "string",
      "phone": "string",
      "subscriberId": "string",
      "updatedAt": "string"
    }
  }
  ```
</ResponseExample>


# Update provider credentials
Source: https://v0.x-docs.novu.co/api-reference/subscribers/update-subscriber-credentials

put /v1/subscribers/{subscriberId}/credentials
Update credentials for a provider such as **slack** and **FCM**. 
      **providerId** is required field. This API creates the **deviceTokens** or replaces the existing ones.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update subscriber global preferences
Source: https://v0.x-docs.novu.co/api-reference/subscribers/update-subscriber-global-preference

patch /v1/subscribers/{subscriberId}/preferences

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update subscriber online status
Source: https://v0.x-docs.novu.co/api-reference/subscribers/update-subscriber-online-status

patch /v1/subscribers/{subscriberId}/online-status
Update the subscriber online status by its unique key identifier **subscriberId**

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SingleSubscriberResponse;
  import co.novu.api.subscribers.requests.UpdateSubscriberOnlineStatusRequest;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";

          UpdateSubscriberOnlineStatusRequest request = new UpdateSubscriberOnlineStatusRequest();
          request.setIsOnline(true);

          SingleSubscriberResponse response = novu.updateSubscriberOnlineStatus(request, subscriberId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "__v": "number",
      "_environmentId": "string",
      "_id": "string",
      "_organizationId": "string",
      "avatar": "string",
      "channels": [
        {
          "_integrationId": "string",
          "credentials": {
            "channel": "string",
            "deviceTokens": [
              "string"
            ],
            "webhookUrl": "string"
          },
          "integrationIdentifier": "string",
          "providerId": "slack"
        }
      ],
      "createdAt": "string",
      "deleted": "boolean",
      "email": "string",
      "firstName": "string",
      "isOnline": "boolean",
      "lastName": "string",
      "lastOnlineAt": "string",
      "locale": "string",
      "phone": "string",
      "subscriberId": "string",
      "updatedAt": "string"
    }
  }
  ```
</ResponseExample>


# Update subscriber preference
Source: https://v0.x-docs.novu.co/api-reference/subscribers/update-subscriber-preference

patch /v1/subscribers/{subscriberId}/preferences/{templateId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.requests.UpdateSubscriberPreferenceRequest;
  import co.novu.api.subscribers.responses.SingleSubscriberPrefResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";
          String templateId = "<TEMPLATE_ID>";

          PreferenceChannel channel = new PreferenceChannel();
          channel.setType("<TYPE>");
          channel.setEnabled(true);

          UpdateSubscriberPreferenceRequest request = new UpdateSubscriberPreferenceRequest();
          request.setEnabled(false);
          request.setChannel(channel);

          SingleSubscriberPrefResponse response = novu.updateSubscriberPreferences(request, subscriberId, templateId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "preference": {
        "channels": {
          "chat": "boolean",
          "email": "boolean",
          "in_app": "boolean",
          "push": "boolean",
          "sms": "boolean"
        },
        "enabled": "boolean"
      },
      "template": {
        "_id": "string",
        "critical": "boolean",
        "name": "string"
      }
    }
  }
  ```
</ResponseExample>


# Check topic subscriber
Source: https://v0.x-docs.novu.co/api-reference/topics/check-topic-subscriber

get /v1/topics/{topicKey}/subscribers/{externalSubscriberId}
Check if a subscriber belongs to a certain topic

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Delete topic
Source: https://v0.x-docs.novu.co/api-reference/topics/delete-topic

delete /v1/topics/{topicKey}
Delete a topic by its topic key if it has no subscribers

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Filter topics
Source: https://v0.x-docs.novu.co/api-reference/topics/filter-topics

get /v1/topics
Returns a list of topics that can be paginated using the `page` query parameter and filtered by the topic key with the `key` query parameter

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get topic
Source: https://v0.x-docs.novu.co/api-reference/topics/get-topic

get /v1/topics/{topicKey}
Get a topic by its topic key

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Rename a topic
Source: https://v0.x-docs.novu.co/api-reference/topics/rename-a-topic

patch /v1/topics/{topicKey}
Rename a topic by providing a new name

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Subscribers addition
Source: https://v0.x-docs.novu.co/api-reference/topics/subscribers-addition

post /v1/topics/{topicKey}/subscribers
Add subscribers to a topic by key

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Subscribers removal
Source: https://v0.x-docs.novu.co/api-reference/topics/subscribers-removal

post /v1/topics/{topicKey}/subscribers/removal
Remove subscribers from a topic

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Topic creation
Source: https://v0.x-docs.novu.co/api-reference/topics/topic-creation

post /v1/topics
Create a topic

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Create workflow group
Source: https://v0.x-docs.novu.co/api-reference/workflow-groups/create-workflow-group

post /v1/notification-groups
workflow group was previously named notification group

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request POST \
  --url https://api.novu.co/v1/notification-groups \
  --header 'Authorization: ApiKey <NOVU_API_KEY>' \
  --header 'Content-Type: application/json' \
  --data '{"name": "insert-name"}'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationGroups.create("Product Updates");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->createNotificationGroup([
      'name' => '<insert-name>'
  ]);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.create_notification_group({
      'name' => '<insert-name>'
  })
  ```

  ```python Python theme={null}
  from novu.api import NotificationGroupApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationGroupApi(url, api_key).create(
      name = "<The name of the notification group>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.createWorkflowGroup(body);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/notification-groups"
    data := map[string]string{
      "name": "name"
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "_environmentId": "string",
      "_organizationId": "string",
      "_parentId": "string"
    }
  }
  ```
</ResponseExample>


# Delete workflow group
Source: https://v0.x-docs.novu.co/api-reference/workflow-groups/delete-workflow-group

delete /v1/notification-groups/{id}
workflow group was previously named notification group

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request DELETE \
  --url https://api.novu.co/v1/notification-groups/{id} \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationGroups.delete("notificationGroupId");
  ```

  ```php PHP theme={null}
  <?php

  $url = 'https://api.novu.co/v1/notification-groups/:id';
  $data = array(
    [options]
  );
  $options = array(
    "http" => array(
    "header"  => "Content-type: application/json",
    "header"  => "Authorization: ApiKey REPLACE_WITH_API_KEY",
    "method"  => "DELETE",
    "content" => json_encode($data)
    )
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);

  if ($result === FALSE) { /* Handle error */ }

  echo $result;
      
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'uri'

  uri = URI.parse('https://api.novu.co/v1/notification-groups/:id')
  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri)

  request.body = '{
    [options]
  }'
  request.content_type = 'application/json'
  request.add_field('Authorization', 'ApiKey REPLACE_WITH_API_KEY')


  response = http.request(request)

  puts response.body
      
  ```

  ```python Python theme={null}
  import requests

  response = requests.delete('https://api.novu.co/v1/notification-groups/:id')

  print(response.json())
      
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/notification-groups/:id"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("DELETE", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "acknowledged": true,
      "status": "deleted"
    }
  }
  ```
</ResponseExample>


# Get workflow group
Source: https://v0.x-docs.novu.co/api-reference/workflow-groups/get-workflow-group

get /v1/notification-groups/{id}
workflow group was previously named notification group

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notification-groups/{id} \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationGroups.getOne("notificationGroupId");
  ```

  ```php PHP theme={null}
  <?php

  $url = 'https://api.novu.co/v1/notification-groups/:id';
  $data = array(
    [options]
  );
  $options = array(
    "http" => array(
    "header"  => "Content-type: application/json",
    "header"  => "Authorization: ApiKey REPLACE_WITH_API_KEY",
    "method"  => "GET",
    "content" => json_encode($data)
    )
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);

  if ($result === FALSE) { /* Handle error */ }

  echo $result;
      
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'uri'

  uri = URI.parse('https://api.novu.co/v1/notification-groups/:id')
  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri)

  request.body = '{
    [options]
  }'
  request.content_type = 'application/json'
  request.add_field('Authorization', 'ApiKey REPLACE_WITH_API_KEY')


  response = http.request(request)

  puts response.body
      
  ```

  ```python Python theme={null}
  import requests

  response = requests.get('https://api.novu.co/v1/notification-groups/:id')

  print(response.json())
      
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/notification-groups/:id"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("GET", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}

    "data": {
      "_id": "string",
      "name": "string",
      "_environmentId": "string",
      "_organizationId": "string",
      "_parentId": "string"
    }
  }
  ```
</ResponseExample>


# Get workflow groups
Source: https://v0.x-docs.novu.co/api-reference/workflow-groups/get-workflow-groups

get /v1/notification-groups
workflow group was previously named notification group

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notification-groups \
  --header 'Authorization: ApiKey <NOVU_API_KEY>' \
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationGroups.get();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->getNotificationGroups()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.notification_groups()
  ```

  ```python Python theme={null}
  from novu.api import NotificationGroupApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationGroupApi(url, api_key).list(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.notificationGroups();
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/notification-groups"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("GET", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "name": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_parentId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Update workflow group
Source: https://v0.x-docs.novu.co/api-reference/workflow-groups/update-workflow-group

patch /v1/notification-groups/{id}
workflow group was previously named notification group

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request PATCH \
  --url https://api.novu.co/v1/notification-groups/{id} \
  --header 'Authorization: ApiKey <NOVU_API_KEY>' \
  --header 'Content-Type: application/json' \
  --data '{"name": "insert-new-name"}'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationGroups.update("notificationGroupId", { name: "Changelog Updates"});
  ```

  ```php PHP theme={null}
  <?php

  $url = 'https://api.novu.co/v1/notification-groups/:id';
  $data = array(
    "name": "name"
  );
  $options = array(
    "http" => array(
    "header"  => "Content-type: application/json",
    "header"  => "Authorization: ApiKey REPLACE_WITH_API_KEY",
    "method"  => "PATCH",
    "content" => json_encode($data)
    )
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);

  if ($result === FALSE) { /* Handle error */ }

  echo $result;
      
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'uri'

  uri = URI.parse('https://api.novu.co/v1/notification-groups/:id')
  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri)

  request.body = '{
    "name": "name"
  }'
  request.content_type = 'application/json'
  request.add_field('Authorization', 'ApiKey REPLACE_WITH_API_KEY')


  response = http.request(request)

  puts response.body
      
  ```

  ```python Python theme={null}
  import requests

  response = requests.patch('https://api.novu.co/v1/notification-groups/:id', json={
        "name": "name",
  }, headers={
      'Content-Type': 'application/json'
      'Authorization': 'ApiKey REPLACE_WITH_API_KEY'
  })

  print(response.json())
      
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.updateWorkflowGroup(workflowId, body);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/notification-groups/:id"
    data := map[string]string{
      "name": "name"
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("PATCH", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "_environmentId": "string",
      "_organizationId": "string",
      "_parentId": "string"
    }
  }
  ```
</ResponseExample>


# Create workflow overrides
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/create-workflow-overrides

post /v1/workflow-overrides

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Delete workflow override
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/delete-workflow-override

delete /v1/workflow-overrides/{overrideId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get workflow override
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/get-workflow-override

get /v1/workflow-overrides/workflows/{workflowId}/tenants/{tenantId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get workflow override by id
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/get-workflow-override-by-id

get /v1/workflow-overrides/{overrideId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get workflow overrides
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/get-workflow-overrides

get /v1/workflow-overrides

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update workflow override
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/update-workflow-override

put /v1/workflow-overrides/workflows/{workflowId}/tenants/{tenantId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update workflow override by id
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/update-workflow-override-by-id

put /v1/workflow-overrides/{overrideId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Create workflow
Source: https://v0.x-docs.novu.co/api-reference/workflows/create-workflow

post /v1/workflows
Workflow was previously named notification template

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request POST \
    --url https://api.novu.co/v1/workflows \
    --header 'Authorization: <authorization>' \
    --header 'Content-Type: application/json' \
    --data '{
      "name": "<name>",
      "notificationGroupId":"<notificationGroupId>",
      "steps": [{ "steps" }]
    }'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.create({
    name: 'Onboarding Workflow',
    // taking first workflow group id
    notificationGroupId: workflowGroupsData.data[0]._id,
    steps: [
      // Adding one chat step
      {
        active: true,
        shouldStopOnFail: false,
        // UUID is optional.
        uuid: '78ab8c72-46de-49e4-8464-257085960f9e',
        name: 'Chat',
        filters: [
          {
            value: 'AND',
            children: [
              {
                field: '{{chatContent}}',
                value: 'flag',
                operator: 'NOT_IN',
                // 'payload'
                on: FilterPartTypeEnum.PAYLOAD,
              },
            ],
          },
        ],
        template: {
          // 'chat'
          type: StepTypeEnum.CHAT,
          active: true,
          subject: '',
          variables: [
            {
              name: 'chatContent',
              // 'String'
              type: TemplateVariableTypeEnum.STRING,
              required: true,
              "defaultValue": "default message",
            },
          ],
          content: '{{chatContent}}',
          contentType: 'editor',
        },
      },
    ],
    description: 'Onboarding workflow to trigger after user sign up',
    active: true,
    draft: false,
    critical: false,
  });
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->createNotificationTemplate([
    "name" => "name",
    "notificationGroupId" => "notificationGroupId",
    "tags" => ["tags"],
    "description" => "description",
    "steps" => ["steps"],
    "active" => true,
    "draft" => true,
    "critical" => true,
    "preferenceSettings" => preferenceSettings
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  body = {
      'name' => '<insert-name>',
      'notificationGroupId' => 'notificationGroupId',
      'tags' => ['tags'], # optional
      'description' => 'description', # optional
      'steps' => [ # optional
         # insert all fields here
      ], 
      'active' => true, # optional
      'draft' => true, # optional
      'critical' => true, # optional
      'preferenceSettings' => { # optional
         # insert all fields here
      },
      'blueprintId' => 'blueprintId' # optional
  }
  client.create_notification_template(body)
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).create(
      notification_template = "< The notification template form definition>",
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.createWorkflow(body);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows"
    data := map[string]string{
      "name": "name",
      "notificationGroupId": "notificationGroupId",
      "tags": ["tags"],
      "description": "description",
      "steps": ["steps"],
      "active": true,
      "draft": true,
      "critical": true,
      "preferenceSettings": preferenceSettings,
      "blueprintId": "blueprintId",
      "data": data
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.createWorkflow

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.createWorkflow(body)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "description": "string",
      "active": true,
      "draft": true,
      "preferenceSettings": {
        "email": true,
        "sms": true,
        "in_app": true,
        "chat": true,
        "push": true
      },
      "critical": true,
      "tags": [
        "string"
      ],
      "steps": [
        {
          "_id": "string",
          "uuid": "string",
          "name": "string",
          "_templateId": "string",
          "active": true,
          "shouldStopOnFail": true,
          "template": {},
          "filters": [
            {
              "isNegated": true,
              "type": "BOOLEAN",
              "value": "AND",
              "children": [
                {
                  "field": "string",
                  "value": "string",
                  "operator": "LARGER",
                  "on": "subscriber"
                }
              ]
            }
          ],
          "_parentId": {},
          "metadata": {
            "amount": 0,
            "unit": "seconds",
            "digestKey": "string",
            "type": "regular",
            "backoff": true,
            "backoffAmount": 0,
            "backoffUnit": "seconds",
            "updateMode": true
          },
          "replyCallback": {}
        }
      ],
      "_organizationId": "string",
      "_creatorId": "string",
      "_environmentId": "string",
      "triggers": [
        {
          "type": "string",
          "identifier": "string",
          "variables": [
            {
              "name": "string"
            }
          ],
          "subscriberVariables": [
            {
              "name": "string"
            }
          ]
        }
      ],
      "_notificationGroupId": "string",
      "_parentId": "string",
      "deleted": true,
      "deletedAt": "string",
      "deletedBy": "string",
      "notificationGroup": {
        "_id": "string",
        "name": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_parentId": "string"
      },
      "data": {},
      "workflowIntegrationStatus": {}
    }
  }
  ```
</ResponseExample>


# Delete workflow
Source: https://v0.x-docs.novu.co/api-reference/workflows/delete-workflow

delete /v1/workflows/{workflowId}
Workflow was previously named notification template

***

## openapi: post /v1/workflows

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request DELETE \
    --url https://api.novu.co/v1/workflows/{workflowId} \
    --header 'Authorization: <authorization>' \
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.delete("workflowId");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->deleteNotificationTemplate($templateId);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.delete_notification_template('<insert-template-id>')
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).delete(
      notification_template_id="<The notification workflow ID of the workflow to be deleted >"
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.deleteWorkflow(workflowId);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows/:workflowId"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("DELETE", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.deleteWorkflow

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.deleteWorkflow(workflowId)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": true
  }
  ```
</ResponseExample>


# Get workflow
Source: https://v0.x-docs.novu.co/api-reference/workflows/get-workflow

get /v1/workflows/{workflowIdOrIdentifier}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request GET \
    --url https://api.novu.co/v1/workflows/{workflowIdOrIdentifier} \
    --header 'Authorization: <authorization>'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.getOne("workflowIdOrIdentifier");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getANotificationTemplate($templateId);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.notification_template('<insert-template-id>')
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).get(
      notification_template_id = "< The ID of the notification template>",
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.getWorkflow(workflowId);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("GET", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.getWorkflow

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.getWorkflow(workflowId)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "preferenceSettings": {
              "email": true,
              "sms": true,
              "in_app": true,
              "chat": true,
              "push": true
          },
          "_id": "7u83d3123t3a9e261ba9934r8",
          "name": "chat with Discord",
          "active": true,
          "draft": false,
          "critical": true,
          "isBlueprint": false,
          "_notificationGroupId": "641eddefda8256b93f750e0b",
          "tags": [],
          "triggers": [
              {
                  "type": "event",
                  "identifier": "chat-with-discord",
                  "variables": [
                      {
                          "name": "chatMsg",
                          "type": "String",
                          "_id": "7u83d3123t3a9e261ba9934r8",
                          "id": "7u83d3123t3a9e261ba9934r8"
                      }
                  ],
                  "reservedVariables": [],
                  "subscriberVariables": [],
                  "_id": "7u83d3123t3a9e261ba9934r8",
                  "id": "7u83d3123t3a9e261ba9934r8"
              }
          ],
          "steps": [
              {
                  "metadata": {
                      "timed": {
                          "weekDays": [],
                          "monthDays": []
                      }
                  },
                  "active": true,
                  "shouldStopOnFail": false,
                  "uuid": "9799f1c9-0de2-4252-8921-01840a71a741",
                  "name": "Chat",
                  "filters": [
                      {
                          "children": [],
                          "_id": "7u83d3123t3a9e261ba99376e",
                          "id": "7u83d3123t3a9e261ba993999"
                      }
                  ],
                  "_templateId": "6533d389306c4d8cf7853557",
                  "_parentId": null,
                  "_id": "99u3d3123t3a9e261ba993r45",
                  "id": "90uid3123t3a9e261ba9978yu",
                  "template": {
                      "_id": "r567d3123t3a9e261ba9990as",
                      "type": "chat",
                      "active": true,
                      "subject": "",
                      "variables": [
                          {
                              "name": "chatMsg",
                              "type": "String",
                              "required": false,
                              "_id": "2383d3123t3a9e261ba997878",
                              "id": "8711d389306c4d8cf7859090"
                          }
                      ],
                      "content": "{{chatMsg}}",
                      "contentType": "editor",
                      "_environmentId": "234edtyuda8256b93f7567f90",
                      "_organizationId": "333tydefda8256b93f753yh6",
                      "_creatorId": "63123ee5d9af70da9f6a2e4",
                      "_feedId": null,
                      "_layoutId": null,
                      "deleted": false,
                      "createdAt": "2023-10-21T13:35:05.825Z",
                      "updatedAt": "2023-10-21T13:35:18.156Z",
                      "__v": 0,
                      "id": "7u83d3123t3a9e261ba9934r8"
                  }
              }
          ],
          "_environmentId": "234edtyuda8256b93f7567f90",
          "_organizationId": "333tydefda8256b93f753yh6",
          "_creatorId": "63123ee5d9af70da9f6a2e4",
          "deleted": false,
          "createdAt": "2023-10-21T13:34:48.130Z",
          "updatedAt": "2023-10-21T13:35:18.994Z",
          "__v": 0,
          "id": "7u83d3123t3a9e261ba9934r8"
      }
  }
  ```
</ResponseExample>


# Get workflows
Source: https://v0.x-docs.novu.co/api-reference/workflows/get-workflows

get /v1/workflows
Workflows were previously named notification templates

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request GET \
    --url https://api.novu.co/v1/workflows \
    --header 'Authorization: <authorization>'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.getAll({
    page: 0, // optional
    limit: 20 // optional
  });
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getNotificationTemplates()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.notification_templates({
      'page' => 4, # optional
      'limit' => 10, # optional
  })
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).list(
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.getWorkflows(page, limit);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("GET", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.getWorkflows

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.getWorkflows(page, limit)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "page": 0,
      "data": [
          {
              "_id": "64f07ea63f28d769494bd74a",
              "name": "Chat with Novu",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "sms-docs",
                      "variables": [
                          {
                              "name": "payloadVar",
                              "type": "String",
                              "_id": "64f1df7a97770dc90cf8c951"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "64f07ea63f28d769494bd74b",
                      "reservedVariables": []
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "0c22b8e5-762f-49b3-b686-09edb2275e8d",
                      "name": "Chat",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64f1ddba1dde0257bca4352d"
                          }
                      ],
                      "_templateId": "64f1ddba1dde0257bca4351d",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64f1ddba1dde0257bca4351d",
                      "template": {
                          "_id": "64f1ddba1dde0257bca4351d",
                          "type": "chat"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-08-31T11:51:02.984Z",
              "updatedAt": "2023-09-01T12:56:26.881Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "64f024843f28d7694946d097",
              "name": "in-app workflow",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "in-app-workflow",
                      "variables": [
                          {
                              "name": "messageIdentifier",
                              "type": "String",
                              "_id": "64f02b28dd99c21f1e2d4ac7"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "64f024843f28d7694946d098"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "ba437658-522d-439f-94da-02426b42d616",
                      "name": "In-App",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64f02b1914b8a3ace6186985"
                          }
                      ],
                      "_templateId": "64f02b1914b8a3ace618697a",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64f02b1914b8a3ace618697a",
                      "template": {
                          "_id": "64f02b1914b8a3ace618697a",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-08-31T05:26:28.637Z",
              "updatedAt": "2023-08-31T05:54:48.445Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "64eec9583cd25fad61223897",
              "name": "Discord chat demo",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "discord-chat-demo",
                      "variables": [
                          {
                              "name": "chatMsg",
                              "type": "String",
                              "_id": "64eed56c735c8d00d98d2a71"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "64eec9583cd25fad61223898"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "03bb2304-d18c-4dc1-ae5a-62fe2634e787",
                      "name": "Chat",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64eeca4faed841efdcaf95eb"
                          }
                      ],
                      "_templateId": "64eeca4faed841efdcaf95e2",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64eeca4faed841efdcaf95e2",
                      "template": {
                          "_id": "64eeca4faed841efdcaf95e2",
                          "type": "chat"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-08-30T04:45:12.419Z",
              "updatedAt": "2023-08-30T05:36:44.465Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "64db9511c51d09cdd01ff086",
              "name": "testing from browser",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "testing-from-browser",
                      "variables": [],
                      "subscriberVariables": [],
                      "_id": "64db9511c51d09cdd01ff087"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "29a67140-4694-443b-b4e1-8111b399198a",
                      "name": "testting browser",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64db954a98ca413e3d6838a7"
                          }
                      ],
                      "_templateId": "64db954a98ca413e3d68389d",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64db954a98ca413e3d68389d",
                      "template": {
                          "_id": "64db954a98ca413e3d68389d",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-08-15T15:09:05.828Z",
              "updatedAt": "2023-08-25T11:55:48.583Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "64c0e3b9ec5b16b5d790d55a",
              "name": "headless-demo",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "headless-demo",
                      "variables": [
                          {
                              "name": "description",
                              "type": "String",
                              "_id": "64c0e3d2ec5b16b5d790d5f6"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "64c0e3b9ec5b16b5d790d55b"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "e0ba19d2-7833-4525-971c-4f40dd47e2ff",
                      "name": "In-App",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64c0e3d2ec5b16b5d790d5f5"
                          }
                      ],
                      "_templateId": "64c0e3d2ec5b16b5d790d5ea",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64c0e3d2ec5b16b5d790d5ea",
                      "template": {
                          "_id": "64c0e3d2ec5b16b5d790d5ea",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-07-26T09:13:29.090Z",
              "updatedAt": "2023-07-26T09:13:54.856Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "64a41ffee2134f0077e0d222",
              "name": "emailDigestWorkflow",
              "active": true,
              "draft": false,
              "critical": false,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "emaildigestworkflow",
                      "variables": [],
                      "subscriberVariables": [
                          {
                              "name": "email",
                              "_id": "64b8f8c024a8ba51900fece6"
                          }
                      ],
                      "_id": "64a41ffee2134f0077e0d223"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "13b27589-a7ad-47e3-b10d-a1085dd3687d",
                      "name": "Digest",
                      "filters": [],
                      "_templateId": "64a421ae5f8a9af84368c9fe",
                      "_parentId": null,
                      "metadata": {
                          "amount": 20,
                          "unit": "seconds",
                          "type": "regular",
                          "backoffAmount": null,
                          "backoff": false,
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64a421ae5f8a9af84368c9fe",
                      "template": {
                          "_id": "64a421ae5f8a9af84368c9fe",
                          "type": "digest"
                      }
                  },
                  {
                      "active": true,
                      "replyCallback": {
                          "active": false
                      },
                      "shouldStopOnFail": false,
                      "uuid": "4e1d8ebb-355c-4224-8a79-fcbc3c0233a1",
                      "name": "Email",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64a420215f8a9af84368b6b8"
                          }
                      ],
                      "_templateId": "64a420215f8a9af84368b6a6",
                      "_parentId": "64a421ae5f8a9af84368c9fe",
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64a420215f8a9af84368b6a6",
                      "template": {
                          "_id": "64a420215f8a9af84368b6a6",
                          "type": "email"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-07-04T13:34:54.781Z",
              "updatedAt": "2023-07-20T09:05:04.701Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "6492d92f616db8f05a982022",
              "name": "digest showcase",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "digest-showcase",
                      "variables": [],
                      "subscriberVariables": [],
                      "_id": "6492d92f616db8f05a982023"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "556f0514-01b6-46f9-9e3d-72a4c060af54",
                      "name": "Digest",
                      "filters": [],
                      "_templateId": "6492d9735da9bfaf640771a2",
                      "_parentId": null,
                      "metadata": {
                          "amount": 10,
                          "unit": "seconds",
                          "type": "regular",
                          "backoffAmount": null,
                          "backoff": false,
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "6492d9735da9bfaf640771a2",
                      "template": {
                          "_id": "6492d9735da9bfaf640771a2",
                          "type": "digest"
                      }
                  },
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "024a27f4-82da-485c-b4a7-bea05c2631e3",
                      "name": "In-App",
                      "filters": [
                          {
                              "children": [],
                              "_id": "6492d9735da9bfaf640771b6"
                          }
                      ],
                      "_templateId": "6492d9735da9bfaf640771aa",
                      "_parentId": "6492d9735da9bfaf640771a2",
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "6492d9735da9bfaf640771aa",
                      "template": {
                          "_id": "6492d9735da9bfaf640771aa",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-06-21T11:04:15.546Z",
              "updatedAt": "2023-07-19T13:32:18.474Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "6471aa6f3a4ec8a599669991",
              "name": "quickstart",
              "active": true,
              "draft": false,
              "critical": false,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "quickstart",
                      "variables": [
                          {
                              "name": "description",
                              "type": "String",
                              "_id": "6471aaa08b0b51ed173ba8fd"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "6471aa6f3a4ec8a599669992"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "982bf6a1-6f0c-46c6-a8ad-6daa67f327e2",
                      "name": "In-App",
                      "filters": [
                          {
                              "children": [],
                              "_id": "6471aa85720b54f89ed97de3"
                          }
                      ],
                      "_templateId": "6471aa85720b54f89ed97dd8",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "6471aa85720b54f89ed97dd8",
                      "template": {
                          "_id": "6471aa85720b54f89ed97dd8",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-05-27T06:59:59.254Z",
              "updatedAt": "2023-05-27T07:00:48.618Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "6469fc87301d88d6d2b74741",
              "name": "Email quickstart",
              "active": true,
              "draft": false,
              "critical": false,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "email-quickstart",
                      "variables": [
                          {
                              "name": "email",
                              "type": "String",
                              "_id": "646a031c25b1fb30f274ac35"
                          },
                          {
                              "name": "description",
                              "type": "String",
                              "_id": "646a031c25b1fb30f274ac36"
                          }
                      ],
                      "subscriberVariables": [
                          {
                              "name": "email",
                              "_id": "646a031c25b1fb30f274ac34"
                          }
                      ],
                      "_id": "6469fc87301d88d6d2b74742"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "replyCallback": {
                          "active": false
                      },
                      "shouldStopOnFail": false,
                      "uuid": "3b512084-6cba-400c-8644-d9e9bff6bbfc",
                      "name": "Email",
                      "filters": [
                          {
                              "children": [],
                              "_id": "6469fd9bc2c5b74546b2cc80"
                          }
                      ],
                      "_templateId": "6469fd9bc2c5b74546b2cc76",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "6469fd9bc2c5b74546b2cc76",
                      "template": {
                          "_id": "6469fd9bc2c5b74546b2cc76",
                          "type": "email"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-05-21T11:12:07.036Z",
              "updatedAt": "2023-05-21T11:40:12.955Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "6450b033631887e5f013f0df",
              "name": "notif-genenerator",
              "active": true,
              "draft": false,
              "critical": false,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "notif-genenerator",
                      "variables": [
                          {
                              "name": "description",
                              "type": "String",
                              "_id": "645a5b18e1a93324256bdf59"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "6450b033631887e5f013f0e0"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "0486c699-2db4-4868-9ed5-c407acacb728",
                      "name": "In-App",
                      "filters": [
                          {
                              "children": [],
                              "_id": "6450b06e9c851c56f803d489"
                          }
                      ],
                      "_templateId": "6450b06e9c851c56f803d47e",
                      "_parentId": null,
                      "_id": "6450b06e9c851c56f803d47e",
                      "template": {
                          "_id": "6450b06e9c851c56f803d47e",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-05-02T06:39:47.699Z",
              "updatedAt": "2023-05-09T14:39:20.811Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          }
      ],
      "totalCount": 20,
      "pageSize": 10
  }
  ```
</ResponseExample>


# Update workflow
Source: https://v0.x-docs.novu.co/api-reference/workflows/update-workflow

put /v1/workflows/{workflowId}
Workflow was previously named notification template

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request PUT \
    --url https://api.novu.co/v1/workflows/{workflowId} \
    --header 'Authorization: <authorization>' \
    --header 'Content-Type: application/json' \
    --data '{
      "name": "<name>",
    }'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.update("workflowId", {
    name: "Send daily digest email update",
    description: "This workflow will send daily digest email to user at 9:00 AM"
    /**
     * all other fields from create workflow payload
     */
  });
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->updateNotificationTemplate($templateId, [
    "name" => "name",
    "tags" => ["tags"],
    "description" => "description",
    "identifier" => "identifier",
    "steps" => ["steps"],
    "notificationGroupId" => "notificationGroupId",
    "active" => true,
    "critical" => true,
    "preferenceSettings" => preferenceSettings
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  body = {
      'name' => '<insert-name>',
      'notificationGroupId' => 'notificationGroupId',
      'tags' => ['tags'], # optional
      'description' => 'description', # optional
      'steps' => [ # optional
         # insert all fields here
      ], 
      'active' => true, # optional
      'draft' => true, # optional
      'critical' => true, # optional
      'preferenceSettings' => { # optional
         # insert all fields here
      },
      'blueprintId' => 'blueprintId' # optional
  }
  client.update_notification_template('<insert-template-id>', body)
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).update(
      notification_template_id = "< The ID of the notification workflow to be updated>",
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.updateWorkflow(workflowId, body);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows/:workflowId"
    data := map[string]string{
      "name": "name",
      "tags": ["tags"],
      "description": "description",
      "identifier": "identifier",
      "steps": ["steps"],
      "notificationGroupId": "notificationGroupId",
      "critical": true,
      "preferenceSettings": preferenceSettings,
      "data": data
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("PUT", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.updateWorkflow

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.updateWorkflow(workflowId, body)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "description": "string",
      "active": true,
      "draft": true,
      "preferenceSettings": {
        "email": true,
        "sms": true,
        "in_app": true,
        "chat": true,
        "push": true
      },
      "critical": true,
      "tags": [
        "string"
      ],
      "steps": [
        {
          "_id": "string",
          "uuid": "string",
          "name": "string",
          "_templateId": "string",
          "active": true,
          "shouldStopOnFail": true,
          "template": {},
          "filters": [
            {
              "isNegated": true,
              "type": "BOOLEAN",
              "value": "AND",
              "children": [
                {
                  "field": "string",
                  "value": "string",
                  "operator": "LARGER",
                  "on": "subscriber"
                }
              ]
            }
          ],
          "_parentId": {},
          "metadata": {
            "amount": 0,
            "unit": "seconds",
            "digestKey": "string",
            "type": "regular",
            "backoff": true,
            "backoffAmount": 0,
            "backoffUnit": "seconds",
            "updateMode": true
          },
          "replyCallback": {}
        }
      ],
      "_organizationId": "string",
      "_creatorId": "string",
      "_environmentId": "string",
      "triggers": [
        {
          "type": "string",
          "identifier": "string",
          "variables": [
            {
              "name": "string"
            }
          ],
          "subscriberVariables": [
            {
              "name": "string"
            }
          ]
        }
      ],
      "_notificationGroupId": "string",
      "_parentId": "string",
      "deleted": true,
      "deletedAt": "string",
      "deletedBy": "string",
      "notificationGroup": {
        "_id": "string",
        "name": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_parentId": "string"
      },
      "data": {},
      "workflowIntegrationStatus": {}
    }
  }
  ```
</ResponseExample>


# Update workflow status
Source: https://v0.x-docs.novu.co/api-reference/workflows/update-workflow-status

put /v1/workflows/{workflowId}/status
Workflow was previously named notification template

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request PUT \
    --url https://api.novu.co/v1/workflows/{workflowId}/status \
    --header 'Authorization: <authorization>' \
    --header 'Content-Type: application/json' \
    --data '{
      "active": "<boolean>",
     }'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.updateStatus("workflowId", false)
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->updateNotificationTemplateStatus($templateId, [
      'active' => true
  ])
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.update_notification_template_status('<insert-template-id>', { 'active' => true })
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).update_status(
      notification_template_id = "< The notification workflow ID of the workflow>",
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.updateWorkflowStatus(workflowId, body);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows/:workflowId/status"
    data := map[string]string{
      "active": true
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("PUT", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.updateWorkflowStatus

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.updateWorkflowStatus(workflowId, body)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "description": "string",
      "active": true,
      "draft": true,
      "preferenceSettings": {
        "email": true,
        "sms": true,
        "in_app": true,
        "chat": true,
        "push": true
      },
      "critical": true,
      "tags": [
        "string"
      ],
      "steps": [
        {
          "_id": "string",
          "uuid": "string",
          "name": "string",
          "_templateId": "string",
          "active": true,
          "shouldStopOnFail": true,
          "template": {},
          "filters": [
            {
              "isNegated": true,
              "type": "BOOLEAN",
              "value": "AND",
              "children": [
                {
                  "field": "string",
                  "value": "string",
                  "operator": "LARGER",
                  "on": "subscriber"
                }
              ]
            }
          ],
          "_parentId": {},
          "metadata": {
            "amount": 0,
            "unit": "seconds",
            "digestKey": "string",
            "type": "regular",
            "backoff": true,
            "backoffAmount": 0,
            "backoffUnit": "seconds",
            "updateMode": true
          },
          "replyCallback": {}
        }
      ],
      "_organizationId": "string",
      "_creatorId": "string",
      "_environmentId": "string",
      "triggers": [
        {
          "type": "string",
          "identifier": "string",
          "variables": [
            {
              "name": "string"
            }
          ],
          "subscriberVariables": [
            {
              "name": "string"
            }
          ]
        }
      ],
      "_notificationGroupId": "string",
      "_parentId": "string",
      "deleted": true,
      "deletedAt": "string",
      "deletedBy": "string",
      "notificationGroup": {
        "_id": "string",
        "name": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_parentId": "string"
      },
      "data": {},
      "workflowIntegrationStatus": {}
    }
  }
  ```
</ResponseExample>


# Recipes
Source: https://v0.x-docs.novu.co/guides/cookbook/introduction



This cookbook contains recipes and code samples demonstrating how to accomplish everyday tasks with Novu in your application. Each code example uses our libraries and SDKs.

<Frame>
  <img />
</Frame>

## Fetch Subscriber Feed

A subscriber feed is a list of all In-App messages for a single subscriber. It's a continuous stream of messages displayed in a list that subscribers can scroll through on the frontend via the Notification Center.

It is a dynamic list with **seen** and **unseen** capabilities. Multiple feeds can exist for a subscriber.

<Warning>**Subscriber Feed** is very different from **Activity Feed**. The former is for In-App channels, while the latter is a list of every message and relevant metadata across all channels shown in your dashboard.</Warning>

The code sample below fetches the list of all In-App messages sent to a specific subscriber:

<CodeGroup>
  ```javascript Node.js  theme={null}
  const { data: inAppMessages } = await novu.subscribers.getNotificationsFeed('subscriberId', {
    page: 0,
    limit: 10,

    // it is of type string. By default all feeds messages are fetched
    feedIdentifier: 'Marketing',

    // seen and read filter of type boolean
    seen: true,
    read: true
  });
  ```
</CodeGroup>

## Fetch All Feeds

In-App messages are grouped in Feeds. There can be one or multiple feeds.

The code sample below fetches all the feeds that have been created and exist in the In-App steps:

<CodeGroup>
  ```javascript Node.js  theme={null}
  const { data: feedsData } = await novu.feeds.get();
  ```
</CodeGroup>

## Delete a Message From a Feed

A message is a content sent to a single subscriber over a single channel. Some messages are simple, like SMS, while others have more features and capabilities, such as Email, Chat, In-App.

A single message can be deleted from a Feed. The code sample below shows how to do it:

<CodeGroup>
  ```javascript Node.js  theme={null}
  await novu.messages.deleteById('messageId');
  ```
</CodeGroup>

## Fetch all Messages Sent To All Subscribers

You can retrieve all messages sent to all subscribers. There are a couple of filters you can apply to fetch these messages.

* channel: fetches all messages that were sent via a specific channel, e.g Email, Sms, Push, In-App
* subscriberId: fetches all messages sent to a specific subscriber
* transactionIds: fetches all messages via transaction ids.

<CodeGroup>
  ```javascript Node.js  theme={null}
  import { ChannelTypeEnum } from '@novu/node';

  // All fields are optional
  const listMessagesOptions = {
    // pagination options
    page: 0,
    limit: 20,

    /**
     *  Filter options
     */
    // use ChannelTypeEnum.PUSH for push, ChannelTypeEnum.IN_APP for in-app,
    channel: ChannelTypeEnum.EMAIL, // only email type messages will be fetched
    subscriberId: '6444105141ffb0919496dfcb',
    transactionIds: ['644-41051-41ffb0-919496-dfcb'],
  };

  const { data: messagesData } = await novu.messages.list(listMessagesOptions);
  ```
</CodeGroup>

## Mark an In-App Message as Read/Seen

You can mark an In-App message as read/seen. Messages from other channels: **Email**, **Push**, **Chat**, **Sms** can't be marked as read/seen.

<CodeGroup>
  ```javascript Node.js  theme={null}
  const { data: markMessageAsRead } = await novu.subscribers.markMessageRead(
    'subscriberId',
    'messageId'
  );

  const { data: markMessageAsSeen } = await novu.subscribers.markMessageSeen(
    'subscriberId',
    'messageId'
  );
  ```
</CodeGroup>

## Mark an In-App Message as Read/Unread/Seen/Unseen

You can mark an In-App message as read/unread/seen/unseen. Messages from other channels: **Email**, **Push**, **Chat**, **Sms** can't be marked as read/unread/seen/unseen.

<CodeGroup>
  ```javascript Node.js  theme={null}
  const { data: markMessageAs } = await novu.subscribers.markMessageAs(
    'subscriberId',
    'messageId',
    { seen: true, read: false }
  );
  ```
</CodeGroup>

## Mark all In-App Messages as Read/Unread/Seen/Unseen

You can mark all In-App messages as read/unread/seen/unseen.

Messages from other channels: **Email**, **Push**, **Chat**, **Sms** can't be marked as read/unread/seen/unseen.

<CodeGroup>
  ```javascript Node.js  theme={null}
  import { MarkMessagesAsEnum } from "@novu/node"

  const { data: markAllInAppMessages } = await novu.subscribers.markAllMessagesAs(
     'subscriberId',

     // can be filtered with feed identifiers
     feedIdentifier: ['Marketing', 'Product']

     // MarkMessageAsEnum.READ => It will mark all messages as read
     // MarkMessageAsEnum.SEEN => It will mark all messages as seen
     // MarkMessageAsEnum.UNREAD => It will mark all messages as unread
     // MarkMessageAsEnum.UNSEEN => It will mark all messages as unseen
     markAs: MarkMessageAsEnum.Read
  );
  ```
</CodeGroup>

## Send Slack Notifications

You can send notifications to Slack Channels via Novu like so:

```javascript Node.js theme={null}
import {
  Novu,
  ChatProviderIdEnum
} from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

// Identify Subscriber
await novu.subscribers.identify('<SUBSCRIBER_ID>', {
  firstName: 'newSubForSlackChat',
});

// Set credentials for the Subscriber
await novu.subscribers.setCredentials('<SUBSCRIBER_ID>', ChatProviderIdEnum.Slack, {
  webhookUrl: "<WEBHOOK_URL>",
});

// Trigger slack notification
await novu.trigger('slack', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>'
  },
  payload: {
    chatMsg: '<INSERT_MESSAGE_CONTENT>'
  }
});
```

where `chatMsg` is a payload variable in the workflow editor.

Follow the [full guide](/guides/slack-guide) on how to send Slack notifications using Novu.


# Demo apps
Source: https://v0.x-docs.novu.co/guides/demos/introduction

Experience the power of Novu for triggering, digesting, and receiving notifications via different channels

### 1. Email, In-App Notification & Authentication

<Frame>
  <img />
</Frame>

<CardGroup>
  <Card title="Github" icon="github" href="https://github.com/novuhq/examples/tree/main/vue-nextjs-trigger-inapp-notifications">
    Find the source code here!
  </Card>

  <Card title="Demo" icon="play" href="https://novu-notifications-vue3.vercel.app/">
    Try it yourself first-hand!
  </Card>
</CardGroup>

### 2. Headless Notification Center

<Frame>
  <img />
</Frame>

<CardGroup>
  <Card title="Github" icon="github" href="https://github.com/novuhq/novu-headless-demo-app">
    Find the source code here!
  </Card>

  <Card title="Demo" icon="play" href="https://headlessdemo.vercel.app/">
    Try it yourself first-hand!
  </Card>
</CardGroup>

### 3. Notification Center

<Frame>
  <img />
</Frame>

<CardGroup>
  <Card title="Github" icon="github" href="https://github.com/novuhq/notification-center-demo">
    Find the source code here!
  </Card>

  <Card title="Demo" icon="play" href="https://notification-center-demo.vercel.app/">
    Try it yourself first-hand!
  </Card>
</CardGroup>

### 4. Email Digest Engine

<Frame>
  <img />
</Frame>

<CardGroup>
  <Card title="Github" icon="github" href="https://github.com/novuhq/digest-email-app">
    Find the source code here!
  </Card>

  <Card title="Demo" icon="play" href="https://emaildigest.vercel.app/">
    Try it yourself first-hand!
  </Card>
</CardGroup>

### 5. InApp Digest Engine

<Frame>
  <img />
</Frame>

<CardGroup>
  <Card title="Github" icon="github" href="https://github.com/novuhq/digest-learning-app">
    Find the source code here!
  </Card>

  <Card title="Demo" icon="play" href="https://digestplayground.vercel.app/">
    Try it yourself first-hand!
  </Card>
</CardGroup>


# How to batch product notifications via code
Source: https://v0.x-docs.novu.co/guides/framework-guides/digest

Leverage Novu's Digest Engine to batch product notifications

# Introduction

Learn how to use Novu’s Digest engine to batch notifications. In this guide, you’ll learn how to aggregate multiple messages and send them off as one notification. Follow these steps:

## Getting started

Integrating Novu’s code-first workflow with React.Email for your Next.js application can be done in three steps

1. Create a fully-featured Novu NextJS app with the command below:

```bash theme={null}
npx create-novu-app
```

1. Once this installation is complete, simply `cd` into the directory and start your app using the `npm run dev` command.

Now, we’re all set to send digested notifications but before we do, let’s look at what it is and how it works:

## Digest engine and how it works

Novu’s Digest Engine is designed to consolidate multiple trigger events into a single cohesive message before delivering it to the subscriber. This functionality is essential for managing notification overload and ensuring that users receive meaningful, aggregated updates rather than being bombarded with numerous individual notifications. Here’s how it works:

1. **Event Accumulation**: The digest engine collects multiple trigger events based on a unique `subscriberId` to be delivered as one message.
2. **Batching Events**: The engine batches these events within a specified time interval. This interval can be configured in units of seconds, minutes, hours, days, weeks, or months.
3. **Delivery**: After the accumulation period, the batched events are sent out as a single notification. This consolidated message reduces the frequency of notifications and provides the user with a summary of all relevant events.

## How to digest in a code-first workflow:

1. Write a workflow and add a digest node to it:

```tsx theme={null}
import { Client } from "@novu/framework";

export const client = new Client({
  apiKey: '<YOUR_NOVU_API_KEY>',
  /**
   * Enable this flag only during local development
   */
  strictAuthentication: process.env.NODE_ENV !== "development",
});

export const digestWorkflow = workflow('novu-digest',
  
  async ({ step, payload }) => {
  
    // Add Digest Node
    const digestResult = await step.digest('email-digest', async () => ({
      unit: 'seconds',
      amount: 30,
    }));

    // Send a welcome email
    await step.email('send-email', () => {
      const resObj = {
        subject: `Welcome to Novu`,
        body: (digestResult.events.map((event) => event.payload.text).join('\n')),
      }
      return resObj
    });
  },
  {
    payloadSchema: {
      properties: {
        email: { type: 'string' },
        text: { type: 'string', default: 'Sumit' },
      },
      required: ['text'],
    },
  }
);

```

<Info>
  💡 In the digest node above, you can change the digest duration by setting a value to the key `amount` and changing the value of `unit` to seconds, minutes, hours, days, weeks, or months
</Info>

2. Here’s a simple client-side app with a handler function attached to the `submit` event:

```tsx theme={null}
"use client"
import React, { useState } from "react";

export default function Home() {

  const [email, setEmail] = useState('')
  const [text, setText] = useState('')

  const onClickHandler = async (e: React.FormEvent<HTMLFormElement>) => {
    try {
      e.preventDefault();
      await fetch("/api/users", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          email: email,
          text: text,
        }),
      });

      // console.log('working fine');
    } catch (error) {
      console.error('Error:', error);
    }
  };
  return (
    <main style={{ height: '100vh', display: 'flex', justifyContent: 'center', alignItems: 'center' }}>
      <form onSubmit={(e) => onClickHandler(e)}>
        <input
          placeholder="Enter email id"
          onChange={(e) => setEmail(e.target.value)}
          style={{
            // Add your CSS-in-JS styles here
            padding: '0.5rem',
            marginBottom: '1rem',
            borderRadius: '0.25rem',
            border: '1px solid #ccc',
            width: '100%',
            boxSizing: 'border-box',
          }}
        />
        <input
          placeholder="Enter the notification text"
          onChange={(e) => setText(e.target.value)}
          style={{
            // Add your CSS-in-JS styles here
            padding: '0.5rem',
            marginBottom: '1rem',
            borderRadius: '0.25rem',
            border: '1px solid #ccc',
            width: '100%',
            boxSizing: 'border-box',
          }}
        />
        <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'center' }}>

          <button
            style={{
              // Add your CSS-in-JS styles here
              padding: '0.5rem 1rem',
              backgroundColor: '#4CAF50',
              color: 'white',
              border: 'none',
              borderRadius: '0.25rem',
              cursor: 'pointer',
            }}
          >
            Submit
          </button>
        </div>
      </form>
    </main>
  );
}

```

3. And the corresponding route that it hits once the event fires:

```tsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<YOUR_NOVU_API_KEY>');

export async function POST(request: Request) {
    const res = await request.json();

    await novu.trigger('novu-digest', {
        to: {
            subscriberId: 'novu-sub-digest',
        },
        payload: {
            email: res.email,
            text: res.text
        },
    });

    console.log('triggered')
    return Response.json({ success: true });
}

```

That’s it!

That’s how simple it is to use Novu’s Digest Engine. Digesting notifications enhances the user experience by providing comprehensive summaries, making it easier for users to stay informed about important updates in a concise manner, without straining users with too many notifications. We have got a thorough guide on digesting notifications [in our docs](https://docs.novu.co/guides/add-digest-to-email-notifications) that you can check out as well.


# Centralized multiple legacy implementations of different teams
Source: https://v0.x-docs.novu.co/guides/usecases/centralized-multiple-legacy-implementations

Learn to use Novu to centralize legacy notification implementations.

If you're coming from a medium or large team with multiple implementations of sending notifications across channels, then you can be rest assured that Novu will be the central gateway.

* Install Novu's SDK (according to your preferred tech).
* Connect your existing delivery providers to Novu.
* [Migrate your users to subscribers](/subscribers/subscribers#import-subscribers) on Novu either via Cloud or on-prem.
* Now, every notification fires via Novu.

Teams in charge of content can always update the workflow templates via the dashboard. Engineers can always debug and add as many providers or activate as many more channels needed!


# Debug notifications across channels in a single place
Source: https://v0.x-docs.novu.co/guides/usecases/debug-notifications

Understand the lifecycle of your notifications

Debugging notifications can be a hassle. Novu allows you understand and debug notifications sent across different channels in one place.

In [Novu's Activity Feed](https://web.novu.co/activities?utm_campaign=docs-usecases-debug), you can access a log of all the notifications that have been sent & filter through the successful & failed ones. Furthermore, you'll know why it failed!

You can filter through channels, workflows, emails, subscribers and transactions.

<Frame>
  <img />
</Frame>

<br />

<Frame>
  <img />
</Frame>

[Explore more about Novu’s Activity Feed](/activity-feed/introduction)


# Digest multiple events in a single notification
Source: https://v0.x-docs.novu.co/guides/usecases/digest-multiple-events

Learn to leverage Novu in digesting multiple events.

One of the recurring features developers yearn for is the ability to batch multiple notifications and send as one to subscribers.

Novu ships with a built-in digest engine that handles batching and digesting multiple events in a single notification. You can programmatically adjust the digest recurrence or set it from the dashboard.

<Frame>
  <img />
</Frame>

[Explore more about Novu's Digest Feature](/workflows/digest)


# Fully featured embedded notification center
Source: https://v0.x-docs.novu.co/guides/usecases/embedded-notification-center

A real-time fully functional embedded notification center

Novu provides a real-time embedded notification center widget that can simply be dropped into any web application.

<Frame>
  <img />
</Frame>

It's available as a drop-in component for React, Vue and Angular apps. For non-specific frameworks, it's also ready as a bundled web component.

We care about the developer experience so much that we also built a headless, zero-UI version to empower you to hand-craft your notification center.

[Explore a lot more about the Notification Center here](/notification-center/introduction)


# Learn by usecase
Source: https://v0.x-docs.novu.co/guides/usecases/introduction

Learn Novu's Use Cases

Novu is built to empower engineering teams in integrating rich product notification experiences seamlessly without re-inventing the wheel.

It has been thoroughly and beautifully crafted to help individuals, teams, businesses and organizations focus on what truly matters: creating exceptional user experiences and driving engagement through smooth and swift notifications delivery.

The common use cases for using Novu are highlighted below:

<CardGroup>
  <Card title="Managing multiple delivery providers in one place" icon="circle-1" href="/use-cases/multiple-delivery-providers" />

  <Card title="Fully featured embedded Notification Center" icon="circle-2" href="/use-cases/embedded-notification-center" />

  <Card title="Digest multiple events in a single notification" icon="circle-3" href="/use-cases/digest-multiple-events" />

  <Card title="Manage notification in multiple languages" icon="circle-4" href="/use-cases/manage-notifications-in-multiple-languages" />

  <Card title="Processing and sending notifications at any scale" icon="circle-5" href="/use-cases/send-notifications-at-any-scale" />

  <Card title="Centralized multiple legacy implementations of different teams" icon="circle-6" href="/use-cases/centralized-multiple-legacy-implementations" />

  <Card title="Debug notifications across channels and vendors in a singe place" icon="circle-7" href="/use-cases/debug-notifications" />
</CardGroup>


# Manage notifications in multiple languages
Source: https://v0.x-docs.novu.co/guides/usecases/manage-notifications-in-multiple-languages

Learn to send notifications in different languages effortlessly

This feature is currently under development. However if you urgently need this, [reach out to us for more information](https://notify.novu.co/meetings/novuhq/notifications-45min?utm_campaign=novuDocs\&utm_content=notifications-in-multiple-languages-docs).


# Managing multiple delivery providers in one place
Source: https://v0.x-docs.novu.co/guides/usecases/multiple-delivery-providers

Learn to manage many delivery providers across different channels in one dashboard

[Novu's dashboard](https://web.novu.co/integrations?utm_campaign=docs-usecases-multipledelivery) empowers you to manage all your notification delivery providers across Email, Sms, Push and Chat in one place.

You can activate, deactivate, modify settings, set primary and secondary active providers as you wish from the dashboard.

### Integrations Store

<Frame>
  <img />
</Frame>

### Add a new Delivery Provider

<Frame>
  <img />
</Frame>


# Processing and sending notifications at any scale
Source: https://v0.x-docs.novu.co/guides/usecases/send-notifications-at-any-scale

Novu can handle notifications at extremely large scale

[Novu's Cloud](https://web.novu.co?utm_campaign=docs-usecases-notificationsscale) is built to process and send notifications at any scale. For folks using the self-hosted Novu version, you can scale it up as your needs grow.

If you're looking to use Novu on a very large scale & you need to confirm infrastructure & scalability prowess, [please reach out to us for more information](https://notify.novu.co/meetings/novuhq/notifications-45min?utm_campaign=docs-bam-usecases-notificationsscale).


# Account Management
Source: https://v0.x-docs.novu.co/help/account-management



### Creating an account

Novu supports [US](https://web.novu.co/auth/signup?utm_campaign=docs-gs-help-account-mgmt) and [EU](https://eu.web.novu.co/auth/signup?utm_campaign=docs-gs-help-account-mgmt) regions based on where you want your data to be stored. In both the regions, a new account can be created using Github or Email and Password. If you are looking for other ways to signup on Novu, feel free to reach out us at [support@novu.co](mailto:support@novu.co).

### Resetting password

If you have created an account with Novu before, you can reset your password by clicking on `Forgot Your Password?` option on the sign-in page.

### Is US and EU account data synced?

US and EU accounts are completely independent. If you have created an account in the US, you will not be able to login with the same credentials in the EU and vice versa.

### Changing the email associated to my account

If you want to change your account email, please reach out to us at [support@novu.co](mailto:support@novu.co).

### What happens if I change my Github account email?

If you created your Novu account using Github, and you change your email in Github, it will not be reflected in Novu. When you login to Novu using the new Github email, a new account will be created. Please email [support@novu.co](mailto:support@novu.co) to update your email address.

### How do I create a new Organization?

A new organization can be created by writing something in the dropdown in the left bottom corner of the dashboard. As soon you start writing something, an add option will apear. This dropdown can also be used to switch between [organizations](/getting-started/concepts#organization). One organization's data is not visible to other organization members.

### How to change organization name?

We are working on account management feature currently so this option is not available in UI as of now. If you want to change your current organization name, [rename organization api](/api-reference/organizations/rename-organization) can be used. if you face any issue in using api or need any help any changing the organization name, please reach out to us at [support@novu.co](mailto:support@novu.co).

### How to upload multiple image assets similar to logo?

Currently, Novu supports uploading only one logo image per organization. If you want to use other images in workflow step content then a valid absolute url of image can be used with `<img>` tag.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Chat
Source: https://v0.x-docs.novu.co/help/channels/chat



### Can I send a message to a specific user on Slack?

While installing the Slack app, you will be asked the User or Channel to which the message needs to be sent. On selecting a user, a webhookUrl for that user will be generated and Novu will use that webhookUrl to send a message to that specific user.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Email
Source: https://v0.x-docs.novu.co/help/channels/email



### How to override default values of Email?

All values (from, to, subject, body, etc.) can be overridden by using the `overrides` option while triggering the workflow. Please see our [email overrides documentation](/channels-and-providers/email/overview#sending-email-overrides) for more details.

### Sending HTML as the value of a variable

HTML content as a value of step variable can be sent by replacing the double curly braces `{{}}` variable with triple curly braces `{{{}}}` variable. For example, `{{{htmlContent}}}`.

### I have multiple Email Providers or integrations active, how do I associate them to a Workflow?

There can be more than one active email integrations of same or different providers. However only one email integration can be primary at one time per environment. To use a different email integration than your primary integration, the integrationIdentifier field of email overrides can be used. Read about using [different email integration](/channels-and-providers/email/overview#using-different-email-integration) for more details.

### Why am I getting the error “message content could not be generated”?

This error occurs when the HTML content is not properly formatted. Make sure the HTML content is properly formatted and does not contain any syntax errors. Make sure Step Variables are properly formatted and are not missing opening or closing curly braces.

### Can email or phone be used as step variables?

Novu recommends not to use subscriber attributes as step variables. Instead, use the subscriber attributes directly in the step. For example, use `{{subscriber.email}}` instead of `{{email}}` as your step variable. Novu will select the email from subscriber attributes and inject the value in the content.

### How to use Provider templates in place of email content?

Currently, we support external Provider template support for [sendgrid](/channels-and-providers/email/sendgrid#using-sendgrid-template) and [mailersend](/channels-and-providers/email/mailersend#using-mailersend-template) only.

### Can I retrieve only Email content?

Novu does not have a separate API to retrieve email content. However, email content can be retrieved from the email step of the workflow. The email step contains the email content in the `content` field of [get worklfow api](/api-reference/workflows/get-workflow) response.

### How to send inline images in email?

Inline images can be sent using `<img>` tag in the email content. PNG, JPEG, GIF are supported. SVGs are not supported as inline images by most of email clients like gmail, outlook.

### How to add unsubscribe link in emails?

Add `{{unsubscribe}}` variable in email step content editor and send url value of this variable in payload. Create a simple html page to [fetch preferences](https://docs.novu.co/api-reference/subscribers/get-subscriber-preferences) and then use [update preference api](https://docs.novu.co/api-reference/subscribers/update-subscriber-preference) to update.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# In App
Source: https://v0.x-docs.novu.co/help/channels/in-app



### Creating two In-App Notification Centers in one account

To configure your In-App notifications, you must use the In-App integration from our integration store.

To display in-app notifications to users, any SDKs in our [client library](/notification-center/introduction) can be used. Every library requires `applicationIdentifier` and `subscriberId` to fetch notifications. Currently, only one `applicationIdentifier` is supported per environment per organization.

Feel free to reach out to us at [support@novu.co](mailto:support@novu.co) if you have speicific requirements of multiple `applicationIdentifier` per organization.

### Issues with a redirect URL

To redirect to specified redirect url on clicking the in-app notification, notification click event should be handled in client side code. Here is an example in [React](/notification-center/client/react/get-started#onnotificationclick).

### Changing the default colors of the Notification Center

Styling of your In-App Notification Center can be customized using the [styles](/notification-center/client/react/customization#customization-using-styles-prop) prop. If you want to customize only a single component, you can use [available](/notification-center/client/react/customization#popovernotificationcenter-customization) props.

### Additional Security for In-App Notifications

To add an extra layer of security, we recommend using our HMAC encryption feature to eliminate subscriber impersonation Checkout [HMAC](/notification-center/client/react/get-started#hmac-encryption) section for more details.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Push
Source: https://v0.x-docs.novu.co/help/channels/push



### Can I send a Desktop Push notification?

Yes, Desktop Push Notifications can be sent by using a Web Push Notification. It is supported with almost all [push channel](/channels-and-providers/push/overview) providers.

### Why am I getting the error “unexpected provider” with FCM?

The possible reasons for this error are:

* Invalid FCM credentials.
* Invalid or stale FCM token.

### Why am I getting the error “Sending message failed due to Requested entity was not found” with FCM?

* This error occurs when the FCM token is invalid or stale. You can fix this by updating the FCM device token.

### Can I store device tokens for particular FCM integration if I have multiple FCM providers active?

* Device tokens for particular FCM integration can be stored using the `integrationIdentifier` field of [update subscriber credentials api](/api-reference/subscribers/update-subscriber-credentials). `integrationIdentifier` is the unique identifier of the integration which is similar to `providerIdentifier`. It can be copied from the integration form.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# SMS
Source: https://v0.x-docs.novu.co/help/channels/sms



### Why am I getting the error “ subscriber does not have a configured channel”?

This error occurs when a Subscriber is missing `phone` attribute. To fix this error, you need to update the subscriber and set the `phone` attribute with a valid phone number.

### How to change the default sender name for SMS?

First, ensure a custom sendername (sender id or from) is allowed with your Provider. Some countries expect to verify the sender name before using it.

You can change the default sender name for SMS by using [overrides](/channels-and-providers/sms/overview#sending-sms-overrides) field while triggering the workflow.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Content Management
Source: https://v0.x-docs.novu.co/help/content-management



### What is a Layout and how can I use them?

Layout is similar to a style container for email templates. Layouts can be used for your organization’s branding and style. It can be used to define the structure of the email template such as the header, footer, and other common elements. It must have a `{{{body}}}` variable which will be replaced by the actual email template content.

### Can Layouts be used across all channels?

Layouts are specific to Emails.

### Can MJML templates be used in content editors?

Only HTML templates can be used in content editors. We support [handlebar helpers](/content-creation-design/handlebars-helpers) for common use cases like iteration, conditions etc. If you need any specific Handlebar Helpers, please reach out to us at [support@novu.co](mailto:support@novu.co).

### Can the content of one Step be used in another?

Currently each Step has content that is unique to it and can not be reused. If this is important to you, please send us a note at [support@novu.co](mailto:support@novu.co).

### Which Translation Language will be used if the Subscriber’s locale field does not match with translation language files?

If the Subscriber's locale field does not match with Translation locale files, or it is not available, then the defaul language of the translation group will be used. If a default is not set, the automatic fallback is English.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Frequently Asked Questions
Source: https://v0.x-docs.novu.co/help/faq



## Platform

### What is an event?

An event is every call to our [trigger API](https://docs.novu.co/api-reference/events/trigger-event/?utm_campaign=docs-faq) or digested with other notifications into any call can be converted through the Novu logic engine into many different notifications or digested with other ones into one notification. In case a trigger was used for many subscribers at once, it will be calculated per unique subscriber. In case many events are converted into one notification they will be calculated at a lower rate.

### What is a notification?

A notification is any message sent over any channel, after the Novu logic engine, Novu user preferences, and your configuration calculated and crafted the message. A notification can be sent to an email, In-App notification center, chat, push, and more.

### What is the difference between seen and read in the context of notifications?

An in-app notification (message) is marked as seen when you open the notification center and that notification(message) is visible
whereas it is marked as read either by clicking on that notification (message) or clicking the 'Mark as Read' option.

### I want to send millions of events, but only send thousands of notifications, can I?

Sure thing! This can easily be done using Novu’s digest + delay, features allowing for ingesting many events into well crafted must have messages over all channels.

### What are the differences between Novu Cloud and Open Source?

Novu [Open source](https://github.com/novuhq/novu) is a technology available under an MIT license, built and maintained by the Novu community, you can adapt it to your needs, contribute, or simply use docker files and run it. Novu Cloud is a managed service run, managed, and maintained by Novu Cloud version is scalable and robust by design, and uptime SLAs, and includes more business-facing features, that are not available under the Open Source version.

### Can I send more than 1 million events a month on Novu Cloud?

Yes, you absolutely can. Our managed cloud system was built to scale with your usage, so you don’t have to worry about it.

### I need some help configuring Novu, where can I find it?

No worries, we got your back. Many questions can be answered on our [documentation site](https://docs.novu.co/?utm_campaign=docs-faq). If for some reason something is missing, go ahead and use our [Discord](https://discord.gg/novu?ref=docs-faqs), we usually answer right away, and with the help of the community members and moderators, it’s very effective.

### What are the differences between Discord and Intercom support?

We have two main public support channels, Discord and Intercom. Discord is our community support channel supporting anything between self-hosted issues, bugs, code contributions, general discussions, feature requests, Novu-Cloud questions, and don’t forget memes :) On our Intercom support, we focus on Novu-Cloud questions, and ensure we can provide the best support based on our knowledge of Cloud usage.

### Where can I find the roadmap?

Glad you want to see what’s next, check out our roadmap [here](https://roadmap.novu.co/roadmap). Feel free to suggest other things and upvote features and requests.

### Does the Novu In-App notification center work with Angular, Vue, and React?

Yes, it does, The Novu In-App notification center is built using pure HTML components, and wrapped in your most beloved frameworks wrapper to provide a nice and consistent developer experience.

### Do you offer any enterprise plan?

Yes, we do. Enterprise plans are available for teams who require extended enterprise-grade features, and specific SLAs or have unique concerns about PII, security, insurance, or legal. Feel free to reach out to us over Intercom, or go to [contact us](https://novu.co/contact-us/?utm_campaign=docs-faq).

### Do you have offer enterprise support plan?

As part of our enterprise support, you’ll get our usual support channels as well as a Microsoft Teams/Slack/Discord channel. In case you want to add an enterprise support plan, with dedicated technical support, we are happy to offer that next to an active enterprise plan.

### I need more events or enterprise features, can you help?

We sure can. We are happy to work with enterprises and build Novu to support both their needs as well as the grand community ones. From new features, security, and privacy, or if you need to send dozens or hundreds of events a month, we are here to help. Feel free to reach out to us over Chat, or [contact us](https://novu.co/contact-us/?utm_campaign=docs-faq).

### Can I see some examples of how to use Novu?

Code examples can be found on our [Github Repo](https://github.com/novuhq/examples), and [our documentation](https://docs.novu.co/getting-started/your-first-notification?utm_campaign=docs-faq). We have examples for common use cases like sending notifications from a web server, mobile app, or integrating with other services.

### I am missing a channel provider, can I ask for one? Or add it myself?

You sure can, if you just want to ask for a new one, the easiest way is to go to our [Github issues](https://github.com/novuhq/novu/issues), and ask for a [new one](https://github.com/novuhq/novu/issues/new?assignees=\&labels=feature\&template=feature_request.yml\&title=%F0%9F%9A%80+Feature%3A+), just make sure if there is another request you upvote it instead of creating a new one. If you are willing to contribute a provider just go to [how to contribute one](https://docs.novu.co/community/add-a-new-provider?utm_campaign=docs-faq) on our docs, thank you!

### Do you have a status page?

Yes we do, check it out [here](https://novustatus.com/).

### I started using Novu Open Source, and I want to move to Novu Cloud, is there any migration tool?

We are now building an automatic tool to help with this migration process, for now, feel free to ask us over Discord, or at [engineering@novu.co](mailto:engineering@novu.co).

## Pricing

### Can I use Novu free of charge?

Yes, you can. If you send less than 30K events per month, then Novu Cloud is entirely free. Another option is to deploy the Open-Source version of Novu onto your own infrastructure, but that does not give you the unique SLA and global redundancy we have in the Cloud version of Novu.

### What is the pricing?

Pricing page is available [here](https://novu.co/pricing/?utm_campaign=docs-faq).

### If I am sending millions of events, but thousands of notifications, will this affect the price?

That’s a great way to do it, sending many events and only handful of notifications means you are able to convey a lot of value while keeping your subscribers happy. We are not only supporting it, it’s also affecting price. On high-volume events to notification, where digest is heavily used each event is calculated as 1/10 of the normal usage.


# Observability
Source: https://v0.x-docs.novu.co/help/observability

Analyzing your Triggered Events and Notification execution logs

### My Subscribers have preferences set, but the Activity Feed is showing Triggers as being sent.

The Activity Feed is a place each event (Workflow Trigger) is listed. If a Subscriber has a preference to not receive notifications through a certain channel, Novu’s system will adhere to that. However, this is still a valid Trigger as the fanout occurs before preferences are accommodated.

### What does "step filtered by subscriber preferences" mean in the logs?

It means that the Subscriber has set preferences configured and the step was filtered based on that preference. If the subscriber has disabled a step Channel then, the step will be filtered and notification will not be sent to the subscriber.

### How to export Activity Feed data?

Currently, we don't have any option to export activity feed data. But you can use our [API](/api-reference/notification/get-notifications) to fetch the data. If there is a specific system you’re looking to integrate with, please send us a note at [support@novu.co](mailto:support@novu.co).

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Orchestration
Source: https://v0.x-docs.novu.co/help/orchestration



## Digest

### New event triggers are merging an active Digest with an old duration..

When a Digest is created with a set duration and an event is triggered, the Digest stays active ( and will batch the events) until the configured duration is over.

If you change the duration before the initial time period has completed , the previous digest will still be active and the new duration is merged with the old duration Digest until the previous duration is complete.

To remove the previous Digest, use [event cancel api](/api-reference/events/cancel-triggered-event) to cancel all event triggers that are still pending and are merged in active Digests.

### Can I dynamically make the Digest inactive??

Yes, Digest supports conditions and can be applied to your Digest step. If the Triggered Event passes the set conditions, then it will be active or inactive based on the condition.

### Can a Subscriber control the Digest duration and time?

Not currently. The Digest duration  can be changed at the Workflow level only and is applied to all subscribers that Workflow is triggered to. If you have an identified use case for this, please let us know at [support@novu.co](mailto:support@novu.co).

## Delay

### What happens if the delay scheduled date and time is in the past?

If the delay scheduled date and time is in the past, the delay step will fail. Based on the step configuration, workflow will either continue to the next step or workflow will be failed

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Others
Source: https://v0.x-docs.novu.co/help/others



### Workkflows changes are not showing on the changes

If some changes are pending to promote for the same workflow, then Novu merges subsequent changes into the existing change item.

### Getting CORS error with the API

Novu APIs are developed to be used on the server side. If you are using the API from the browser, you will get a CORS error. You can use the API from the server side or checkout our [client-side libraries](/notification-center/introduction) to fetch in-app notifications.


# Help Center Overview
Source: https://v0.x-docs.novu.co/help/overview

Introduction to Novu help center

At our Help Center, we're dedicated to provide comprehensive support to ensure your experience with our products and services is seamless and enjoyable. Whether you're a new user looking for guidance or a seasoned customer seeking assistance, we're here to help. Help Center is organized as per our product architecture and is divided into the following sections:

<CardGroup>
  <Card title="Account Management" href="/help/account-management" icon="user">
    Manage your account and access your data.
  </Card>

  <Card title="User Management" href="/help/user-management" icon="users">
    Manage subscribers and topics
  </Card>

  <Card title="Channels" href="/help/channels" icon="bars">
    Explore all channels and how to use each one.
  </Card>

  <Card title="Orchestration" href="/help/orchestration" icon="screwdriver-wrench">
    Explore orchestration digest, delay, conditions and more.
  </Card>

  <Card title="Content Management" href="/help/content-management" icon="file-pen">
    Content management, layouts, templates, and more.
  </Card>

  <Card title="Observability" href="/help/observability" icon="magnifying-glass">
    Observability, metrics, analytics, and more.
  </Card>

  <Card title="Others" href="/help/Others" icon="crystal-ball">
    Others help topics.
  </Card>

  <Card title="FAQs" href="/help/faq" icon="comment">
    Read frequently asked questions
  </Card>
</CardGroup>

<Frame>
  <img />
</Frame>


# User Management
Source: https://v0.x-docs.novu.co/help/user-management



## Subscribers

### What is a Subscriber?

A subscriber is an entity to which notifications are sent. It is a Novu term similar to a user in your system. As in your system, a user is identified by a unique id, similarly in Novu, a subscriber is identified by a unique id called `subscriberId`. We recommend that the existing value you use in your system as a `userId` to be used as `subscriberId` in Novu. Read more about subscribers on [subscribers documentation page](/subscribers/subscribers).

### Is it necessary to use subscriberId as same as userId?

No, it is not necessary to use subscriberId as same as userId. You can use any unique id as subscriberId. We recommend using userId as subscriberId to avoid any confusion. Some of our customers use a pattern like `auth0|userId` as a value for `subscriberId`.

### Can notification be sent without adding a Subscriber?

No, a notification cannot be sent without adding a subscriber. A subscriber is an entity to which notifications are sent. You need to add a subscriber to Novu before triggering the workflow or inline of trigger. Read more about subscribers on [subscribers documentation page](/subscribers/subscribers).

### What is the right approach to add Subscribers?

Subscribers can be added either [ahead of trigger](/subscribers/subscribers#1-ahead-of-trigger) or [inline of trigger](/subscribers/subscribers#2-inline-of-trigger). One way to add a subscriber using inline of trigger is to create  a new subscriber in Novu as soon as they sign up or register in your system.

You can add your existing users as subscribers in Novu using [bulk create subscriber creation method](/subscribers/subscribers#bulk-subscriber-creation).

### Can Subscriber credentials be added while creating a new Subscriber?

Subscriber credentials for Push and Chat channel providers cannot be added while creating a new subscriber. Subscriber credentials for Push and Chat channel providers can be added using the [update subscriber credentials api](/api-reference/subscribers/update-subscriber-credentials) or corresponding sdk methods.

SMS and Email channels are a bit different because all providers can work with the same value, so `email` and `phone` [attributes](/subscribers/subscribers#subscriber-attributes) can be added while creating a new Subscriber.

### Can Subscriber preferences be updated while adding a new Subscriber?

Subscriber preference cannot be updated while adding a new subscriber. Novu sets all channels as true by default for new subscribers. You can modify preferences at any time. Read more about [subscriber preferences](/subscribers/preferences).

### Can two subscribers with different `subscriberId`s have the same email address?

Yes, it is possible for two subscribers to have the same email address in our system. This is because the `subscriberId` is the unique identifier that distinguishes one subscriber from another. Even if two subscribers share the same email address, they will have different `subscriberId`s, which allows our system to identify and manage them separately.

## Topics

### Can a Subscriber be added to multiple topics at once?

Currently, Novu supports adding a subscriber to only one topic at a time. You can add a subscriber to multiple topics by calling the [add subscriber to topic api](/api-reference/topics/subscribers-addition) multiple times with a particular topic key


# Activity Feed
Source: https://v0.x-docs.novu.co/activity-feed/introduction

Monitor all your activity from one place

## Introduction

Novu provides a notification activity feed that monitors every outgoing message associated with its relevant metadata. This can be used to monitor activity and discover potential issues with a specific provider or channel type.

<Frame>
  <img />
</Frame>

## Viewing a specific subscriber's activity

To use a subscriber's activity feed you can filter the feed by using the subscriberId or email. This will show only the relevant data for this particular subscriber.

To do this, just enter the `subscriberId` or the 'email' of the subscriber you want to get info of and then click the 'search' button on the right-hand side as shown in the image below:

<Frame>
  <img />
</Frame>

## Filter by workflow or channel

The activity feed allows you to filter messages based on the associated workflow or channel. This is helpful when you want to assess or debug a particular workflow and its behaviour.

Filtering by workflow or channel is quite simple. Just go to the Workflow dropdown (if you want to filter by workflow) or the channel tab (if you want to filter by channel) and select the corresponding workflow or channel and click the 'search' button on the right-hand side as shown in the image below:

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Troubleshooting with the activity feed

The activity feed also shows if a transaction is failing. You can see why a transaction is failing and rectify it. For example, take a look at the following image:

<Frame>
  <img />
</Frame>

You can see that an SMS notification has failed to get delivered. Clicking on it opens the execution details and the reason why that transaction failed

<Frame>
  <img />
</Frame>

This can help troubleshoot the problem and comes in handy at the time of distress.

## Digest info in the activity feed

If you’re using our digest notifications functionality, you’ll be able to see all the digest-related information in the activity feed.

<Frame>
  <img />
</Frame>

Some of the information related to digest present in the activity feed is:

* Digest step delay
* Digesting start time
* Digest triggered events details
* More digest execution details

<Frame>
  <img />
</Frame>

From here, you can see the details of ‘digest triggered events’ to see exactly which events were digested and the content of the notification you sent, as shown below:

<Frame>
  <img />
</Frame>

## Trigger Event Lifecycle

### **Trigger request**

The request contains details such as the identifier for the template, the list of subscribers who will receive the notification, the payload of the notification, and any overrides that need to be applied.

### Trigger endpoint

After the request is sent to the `/event/trigger` endpoint, the initial step involves mapping and validating the subscribers for that event. Following that, we validate the template and steps based on the active status or draft template flag.

Once the validation process is complete, the attachments are uploaded to the storage service.

Next, the trigger event with mapped subscribers and attachment links is appended to the **trigger event queue**. By queuing the events, we can achieve faster response times.

### **Trigger event processing**

When the event is picked up by the **trigger queue worker** we process it. For every subscriber listed in the trigger event, we create a notification entity and the corresponding jobs based on the notification template steps. The notification contains data related to the organization, template, subscriber, and event payload. It is updated with a channels field that is generated from the steps.

### **Jobs**

Every job is created according to the steps outlined in the template. If the template contains a digest step, the **filtering logic** is applied to produce the appropriate jobs array depending on the type of digesting: **regular** or **backoff**.


# Trigger Event Lifecycle
Source: https://v0.x-docs.novu.co/activity-feed/trigger-event-lifecycle

Managing Trigger Events from Request to Processing

## Trigger Request

A trigger request is the initial step in handling a trigger event. It contains crucial details such as the template identifier, a list of subscribers who will receive the notification, the payload of the notification, and any overrides that need to be applied.

## Trigger Endpoint

Upon sending the request to the `/event/trigger` endpoint, a series of essential steps are initiated:

1. **Subscriber Mapping and Validation:** The first step involves mapping and validating the subscribers for the specified event. This ensures that notifications are sent to the correct recipients.

2. **Template Validation:** Following subscriber validation, the template associated with the event is validated. This validation process considers factors such as the active status or draft template flag to determine if it meets the necessary criteria for processing.

3. **Attachment Upload:** Once the validation process is successfully completed, any attachments associated with the event are uploaded to the designated storage service.

4. **Event Queuing:** The trigger event, now enriched with mapped subscribers and attachment links, is appended to the **trigger event queue**. This queuing mechanism optimizes response times, ensuring efficient event processing.

## Trigger Event Processing

When an event is picked up by the **trigger queue worker**, the processing phase begins. Here's what happens:

* **Notification Entity Creation:** For each subscriber listed in the trigger event, a corresponding notification entity is created. This entity contains essential data related to the organization, template, subscriber, and event payload.

* **Job Creation:** Based on the notification template's defined steps, jobs are generated. These jobs are responsible for carrying out specific tasks related to the event notification. Additionally, the notification entity is updated with a "channels" field generated from these steps, indicating the communication channels through which notifications will be sent.

## Jobs

Jobs play a pivotal role in the trigger event lifecycle. They are created based on the steps outlined in the notification template. Depending on the presence of a digest step, the following logic is applied:

* **Digest Step:** If the template includes a digest step, filtering logic is applied to produce an appropriate array of jobs. This logic differentiates between two types of digesting: **regular** and **backoff**, each serving distinct purposes in event processing.

## Job Statuses

| Status        | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **PENDING**   | This status is assigned to a job before it is added to the worker queue. It indicates that the job is waiting to be processed.                                                                                                                                                                                                                                                                                                                                                                                                                       |
| **QUEUED**    | After the initial validation and just before adding a job to the worker queue, it is set to `QUEUED`. This status signifies that the job is ready for processing but is awaiting its turn in the queue.                                                                                                                                                                                                                                                                                                                                              |
| **RUNNING**   | When a job is picked up by a worker from the queue, its status is changed to `RUNNING`. This indicates that the job is currently being processed by a worker.                                                                                                                                                                                                                                                                                                                                                                                        |
| **COMPLETED** | Once a job has been successfully executed and processed, its status is changed to `COMPLETED`. This signifies that the job has been successfully completed.                                                                                                                                                                                                                                                                                                                                                                                          |
| **FAILED**    | If a job encounters an issue during processing or execution, its status is changed to `FAILED`. This indicates that the job has not been successfully completed, and there may have been errors or problems during processing.                                                                                                                                                                                                                                                                                                                       |
| **DELAYED**   | The `DELAYED` status is applied to specific types of jobs, such as `digest` or `delay` jobs, to indicate that they are delayed and not immediately processed. For `digest` jobs, it means that the digesting process is running or scheduled for a later time. For `delay` jobs, it signifies that the job is set to be executed at a specified delay time.                                                                                                                                                                                          |
| **CANCELED**  | When a job is canceled for any reason, its status is set to `CANCELED`. This indicates that the job will not be processed further and is effectively removed from the processing queue.                                                                                                                                                                                                                                                                                                                                                              |
| **MERGED**    | The `MERGED` status is assigned to events that are part of a `digest`. It indicates that an event will be merged into the digesting event. In a digesting process, there is typically a primary or initial event that serves as the digesting event, and subsequent events are merged into it. Instead of having a separate `COMPLETED` status for these merged events, they are marked as `MERGED` to indicate their specific role in the digesting process.                                                                                        |
| **SKIPPED**   | The `SKIPPED` status is used in the context of backoff versions of digesting. In this scenario, the first event's digesting is skipped, and the second event takes on the digesting role. The `SKIPPED` status is applied to the first event's digesting, indicating that it was intentionally skipped in the digesting process. Subsequent events may be merged into the second event's digesting process, as explained with the `MERGED` status. The `SKIPPED` status helps differentiate the skipped event from others in the digesting sequence. |

**Example:**

<Frame>
  <img />
</Frame>

<Steps>
  <Step title="Step created">
    `PENDING`
  </Step>

  <Step title="Step queued">
    `QUEUED`
  </Step>

  <Step title="Start sending message">
    `RUNNING`
  </Step>

  <Step title="Message created">
    `RUNNING`
  </Step>

  <Step title="Message sent">
    `COMPLETED`
  </Step>
</Steps>


# Apply change
Source: https://v0.x-docs.novu.co/api-reference/changes/apply-change

post /v1/changes/{changeId}/apply

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.changes.applyOne("changeId");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->applyChange($changeId, []);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.apply_change(`<change_id≥`)
  ```

  ```python Python theme={null}
  from novu.api import ChangeApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = ChangeApi(url, api_key).apply(
      change_id = "<A change ID to apply>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.applyChange('changeId');
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "_creatorId": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_entityId": "string",
        "enabled": true,
        "type": "Feed",
        "change": {},
        "createdAt": "string",
        "_parentId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Apply changes
Source: https://v0.x-docs.novu.co/api-reference/changes/apply-changes

post /v1/changes/bulk/apply

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.changes.applyMany(["changeId1", "changeId2"]);
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->applyBulkChanges([
      'changeIds' = [
          '<insert-all-the-change-ids>'
      ]
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.apply_change({
      'changeIds' => ['<insert-all-the-change-ids>']
  })
  ```

  ```python Python theme={null}
  from novu.api import ChangeApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = ChangeApi(url, api_key).bulk_apply(
      change_ids = "<The list of IDs to apply>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.applyBulkChanges("<list-of-change-ids>");
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "_creatorId": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_entityId": "string",
        "enabled": true,
        "type": "Feed",
        "change": {},
        "createdAt": "string",
        "_parentId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Get execution details
Source: https://v0.x-docs.novu.co/api-reference/execution-details/get-execution-details

get /v1/execution-details

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request GET \
      --url https://api.novu.co/v1/execution-details \
      --header 'Authorization: <authorization>' 
  ```

  ```javascript Node.js theme={null}
  import fetch from 'node-fetch';

  const response = await fetch('https://api.novu.co/v1/execution-details', {
    method: 'GET',
    
  });
  const data = await response.json();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  // Get execution details
  $novu->getExecutionDetails([
      'notificationId' => '<insert-notification-id>',
      'subscriberId'   => '<insert-subscriber-id>'
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.execution_details({
      'notificationId' => '8fxxx-xxx-ef9xxxxce66',
      'subscriberId' => '7789'
  })
  ```

  ```python Python theme={null}
  from novu.api import ExecutionDetailApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = ExecutionDetailApi(url, api_key).list(
      notification_id = "<The notification ID in Novu>",
      subscriber_id = "<The subscriber ID in Novu>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.executionDetails(query = {});
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "_organizationId": "string",
        "_jobId": "string",
        "_environmentId": "string",
        "_notificationId": "string",
        "_notificationTemplateId": "string",
        "_subscriberId": "string",
        "_messageId": "string",
        "providerId": "string",
        "transactionId": "string",
        "channel": "in_app",
        "detail": "string",
        "source": "Credentials",
        "status": "Success",
        "isTest": true,
        "isRetry": true,
        "createdAt": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Create feed
Source: https://v0.x-docs.novu.co/api-reference/feeds/create-feed

post /v1/feeds

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request POST \
  --url https://api.novu.co/v1/feeds \
  --header 'Authorization: ApiKey <NOVU_API_KEY>' \
  --header 'Content-Type: application/json' \
  --data '{"name": "<FEED_NAME>"}'
  ```

  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.feeds.create("<Feed_Name>");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->createFeed([
      'name' => '<insert-name-for-feed>'
  ]);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.create_feed({
      'name' => 'New feed'
  })
  ```

  ```python Python theme={null}
  from novu.api import FeedApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = FeedApi(url, api_key).create(
      name = "<Feed_Name>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.createFeed(body);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "identifier": "string",
      "_environmentId": "string",
      "_organizationId": "string"
    }
  }
  ```
</ResponseExample>


# Delete feed
Source: https://v0.x-docs.novu.co/api-reference/feeds/delete-feed

delete /v1/feeds/{feedId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request DELETE \
  --url https://api.novu.co/v1/feeds/{FEED_IDENTIFIER} \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.feeds.delete("<Feed_Id>");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->deleteFeed();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.delete_feed("<Feed_Id>")
  ```

  ```python Python theme={null}
  from novu.api import FeedApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = FeedApi(url, api_key).delete(
      Feed_Id = "<ID of the feed to be deleted>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.deleteFeed(Feed_Id);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "name": "string",
        "identifier": "string",
        "_environmentId": "string",
        "_organizationId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Get feeds
Source: https://v0.x-docs.novu.co/api-reference/feeds/get-feeds

get /v1/feeds

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/feeds \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.feeds.get();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->getFeeds()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.feeds()
  ```

  ```python Python theme={null}
  from novu.api import FeedApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = FeedApi(url, api_key).list(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.feeds();
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "name": "string",
        "identifier": "string",
        "_environmentId": "string",
        "_organizationId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Get v1blueprints
Source: https://v0.x-docs.novu.co/api-reference/get-v1blueprints

get /v1/blueprints/{templateId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get v1blueprintsgroup by category
Source: https://v0.x-docs.novu.co/api-reference/get-v1blueprintsgroup-by-category

get /v1/blueprints/group-by-category

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Delete a message
Source: https://v0.x-docs.novu.co/api-reference/messages/delete-message

delete /v1/messages/{messageId}
Delete a message entity from the Novu platform by **messageId**. 
    This action is irreversible. **messageId** is required and of mongodbId type.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu, ChannelTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.messages.deleteById("<Message_Id>");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu("<NOVU_API_KEY>");

  $novu->deleteMessage();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.delete_message('<insert-message-id>')
  ```

  ```python Python theme={null}
  from novu.api import MessageApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = MessageApi(url, api_key).delete(
      message_id= "The message ID to delete",    
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.deleteMessage(messageId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "acknowledged": true,
      "status": "deleted"
    }
  }
  ```
</ResponseExample>


# Delete messages by transactionId
Source: https://v0.x-docs.novu.co/api-reference/messages/delete-message-by-transactionid

delete /v1/messages/transaction/{transactionId}
Delete multiple messages from the Novu platform using **transactionId** of triggered event. 
    This API supports filtering by **channel** and delete all messages associated with the **transactionId**.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```cURL theme={null}
  curl --request DELETE \
  --url 'https://api.novu.co/v1/messages/transaction/{transactionId}' \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```
</RequestExample>

<ResponseExample>
  ```json theme={null}
  204 - No Content
  ```
</ResponseExample>


# List all messages
Source: https://v0.x-docs.novu.co/api-reference/messages/get-messages

get /v1/messages
List all messages for the current environment. 
    This API supports filtering by **channel**, **subscriberId**, and **transactionId**. 
    This API returns a paginated list of messages.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu, ChannelTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  const params = {
    page: 0, // optional
    limit: 20, // optional
    subscriberId: "subscriberId"  //optional
    channel: ChannelTypeEnum.EMAIL //optional
    transactionIds : ["txnId1","txnId2"] //optional
  }

  await novu.messages.list(params);
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu("<NOVU_API_KEY>");

  $novu->getMessages();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'channel' => 'slack', # optional
      'subscriberId' => '7789', # optional
      'transactionId' =>'sw900999as', # optional
      'page' => 4, # optional
      'limit' => 10, # optional
  }
  client.messages(payload)
  ```

  ```python Python theme={null}
  from novu.api import MessageApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = MessageApi(url, api_key).list(
      limit= "The number of messages to fetch, defaults to 10",
      page= "The page to fetch, defaults to 0",
      channel = "The channel for the messages you wish to list. Defaults to None.",
      subscriber_id = "The subscriberId for the subscriber you like to list messages for",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.messages(query = {});
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      hasMore: true,
      data: [data],
      pageSize: 0,
      page: 0
  }
  ```
</ResponseExample>


# Create an organization
Source: https://v0.x-docs.novu.co/api-reference/organizations/create-organization

post /v1/organizations

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Remove a member from organization using memberId
Source: https://v0.x-docs.novu.co/api-reference/organizations/delete-member-from-organization

delete /v1/organizations/members/{memberId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Fetch all members of current organizations
Source: https://v0.x-docs.novu.co/api-reference/organizations/get-all-members-of-current-organization

get /v1/organizations/members

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Fetch all organizations
Source: https://v0.x-docs.novu.co/api-reference/organizations/get-all-organizations

get /v1/organizations

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Fetch current organization details
Source: https://v0.x-docs.novu.co/api-reference/organizations/get-current-organization

get /v1/organizations/me

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Rename organization name
Source: https://v0.x-docs.novu.co/api-reference/organizations/rename-organization

patch /v1/organizations

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update member role to admin
Source: https://v0.x-docs.novu.co/api-reference/organizations/update-member-role-to-admin

put /v1/organizations/members/{memberId}/roles

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update organization branding details
Source: https://v0.x-docs.novu.co/api-reference/organizations/update-organization-branding

put /v1/organizations/branding

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Create tenant
Source: https://v0.x-docs.novu.co/api-reference/tenants/create-tenant

post /v1/tenants
Create tenant under the current environment

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Delete tenant
Source: https://v0.x-docs.novu.co/api-reference/tenants/delete-tenant

delete /v1/tenants/{identifier}
Deletes a tenant entity from the Novu platform

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get tenant
Source: https://v0.x-docs.novu.co/api-reference/tenants/get-tenant

get /v1/tenants/{identifier}
Get tenant by your internal id used to identify the tenant

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get tenants
Source: https://v0.x-docs.novu.co/api-reference/tenants/get-tenants

get /v1/tenants
Returns a list of tenants, could paginated using the `page` and `limit` query parameter

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update tenant
Source: https://v0.x-docs.novu.co/api-reference/tenants/update-tenant

patch /v1/tenants/{identifier}
Update tenant by your internal id used to identify the tenant

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Novu Architecture Diagram
Source: https://v0.x-docs.novu.co/architecture/diagrams



# Novu Architecture Diagram powered by [terrastruct](https://terrastruct.com) and D2

If the diagram below is not rendering, please [click here](https://app.terrastruct.com/diagrams/1895866270) to view it on terrastruct.com.

<iframe title="Novu" />


# Introduction to Novu
Source: https://v0.x-docs.novu.co/architecture/introduction

Overview of Novu's Architecture

Novu is an open-source notification infrastructure designed to provide a robust, efficient, and flexible solution for managing notifications across various platforms.
The architecture of Novu is meticulously crafted to ensure accurate delivery of notifications while maintaining high performance and scalability.

Our systems are hosted on Amazon Web Services (AWS), ensuring a reliable and secure environment for our infrastructure.
We adhere to several industry-standard compliance certifications including SOC II, PCI, and GDPR which underline our commitment to security and data privacy.

## Framework Leveraged

* **Nestjs**: A progressive Node.js framework that is used for building efficient, reliable, and scalable server-side applications. Nestjs provides a high-level abstraction with a lot of out-of-the-box features, making it a perfect choice for building modular and maintainable applications.
* **Mongoose**: An elegant Object Document Mapper (ODM) for MongoDB, which simplifies the interaction with the database by providing a straightforward modeling of the application data. Mongoose’s features like schema validation, query building, and middleware support immensely help in building robust applications.
* **BullMQ**: A robust, fast, and reliable queue library for handling distributed jobs and messages in Node.js. It is instrumental in managing the processing of notification jobs ensuring they are handled in an efficient and reliable manner.

## Databases

* **MongoDB**: A NoSQL database that provides high performance, high availability, and easy scalability. It works on a document-oriented data model, which is extremely flexible and allows for varied, complex data structures to be stored and manipulated with ease.
* **Redis**: An in-memory data structure store, used as a database, cache, and message broker. It's exceptionally fast and provides support for various data structures like strings, hashes, lists, sets, etc. It's utilized in Novu for caching and as a reliable message broker for managing queues and real-time data processing.

## Scalability & Performance

The architecture of Novu is designed to scale horizontally to handle a growing number of notification requests. The use of microservices, container orchestration with Kubernetes, and leveraging AWS’s auto-scaling capabilities, ensure that the system can handle high loads while maintaining low latency and high throughput.

## Monitoring & Observability

Monitoring and observability are crucial for ensuring the reliable operation of Novu. Utilizing tools like Prometheus and Grafana, we've built a comprehensive monitoring and alerting system that provides real-time insights into the system’s performance and health.

## Security

Security is a paramount concern in Novu’s architecture. By adhering to industry-standard security practices and compliance certifications, we ensure that the data flowing through Novu is handled securely and in compliance with regulatory requirements.


# Novu Providers
Source: https://v0.x-docs.novu.co/channels-and-providers/default-providers

Learn about the default Novu email and sms providers

## Novu Providers

To help you evaluate our services better, Novu provides an email and sms provider by default for every account. After signing up, you can go to the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-default-providers) on the Novu web dashboard to see this.

<Note>
  This feature is available only in Novu cloud. This feature will not work in community self
  hosted version and local environment.
</Note>

## Novu Email Provider

If you've a newly signed-up account on Novu, it will look like this:

<Frame>
  <img />
</Frame>

## Novu SMS Provider

And this is what the default Novu SMS provider looks like:

<Frame>
  <img />
</Frame>

<Info>
  The default email and sms providers are for evaluation purposes only and their use in production-grade apps is not recommended. You should switch to any of our [numerous other providers](/additional-resources/glossary#3-providers) for production apps. Also, there are two modes for default Novu providers - Development and Production.
</Info>

## Novu In-app Provider

In addition to email and sms, we also have in-app provider:

<Frame>
  <img />
</Frame>

It is the only provider for the in-app channel and it *can be used in production apps*. Unlike sms and email, it is not active by default and needs to be turned on separately. It can be scaled as per your need and it is a 'pay as you go' offering. You can check [this](https://novu.co/pricing/?utm_campaign=docs-default-providers) for more details.

## Limits of the Novu Providers

Following are the limits for our email and sms providers:

1. Email: 300 emails per organization per month
2. SMS: 20 messages per organization per month

To send more than these limits, you can configure a different provider for a specific channel. Read more about them [here](/channels-and-providers/integration-store).


# Amazon SES
Source: https://v0.x-docs.novu.co/channels-and-providers/email/amazon-ses

Learn how to use the Amazon SES provider to send email notifications using Novu

You can use the [Amazon SES](https://aws.amazon.com/ses/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Amazon SES provider in the email channel, you will need to create an SES account and add your credentials to the Amazon SES integration on the Novu platform.

## Setting up SES in AWS?

* Either use a root AWS account or create a new IAM account with appropriate permission policies.
  <Tip>Example policy rule `arn:aws:ses:<REGION>:<ACCOUNT>:identity/*`</Tip>
* Create a new access key and save generated `ACCESS_KEY_ID` and `ACCESS_SECRET_KEY` carefully
* Choose Amazon Simple Email Service.
* Create a new identity.
* Either choose domain or email.
* Verify your domain (by adding a few DNS records as mentioned in SES instructions) or email (AWS sends a verification email to your email).
* Verify the recipient email also by creating a new email identity type \[only in sandbox mode].
* Test if your SES is set up correctly using the test email feature.

## Creating an SES integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-integrations-ses) page on Novu.
* Click on Add a Provider.
* Select Amazon SES service.
* Enter previously saved `ACCESS_KEY_ID` and `ACCESS_SECRET_KEY`.
* Fill in the `From email address` field using the authenticated sender email id in the previous step.
* Enter `region` and `Sender name` also.

<Tip>Example region format:- `us-east-1`. By default Novu uses `us-east-1` region.</Tip>

* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Amazon SES in Novu.

## FAQs

<AccordionGroup>
  <Accordion title="Trigger from novu is successful but the subscriber is not receiving email.">
    Possible reasons:

    1. You have not verified the subscriber's email address in SES (if you are in a sandbox environment).
    2. Your daily sending limit has been reached (if you are in a sandbox environment).
    3. You have entered the wrong aws region in the integration form.
  </Accordion>
</AccordionGroup>


# Braze
Source: https://v0.x-docs.novu.co/channels-and-providers/email/braze

Learn how to use the Braze provider to send email notifications using Novu

You can use the [Braze](https://braze.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Braze provider in the email channel, you will need to create a [Braze account](https://braze.com/) and add your API key and other credentials to the Braze integration on the Novu platform.

# Generating an API Key

To generate a new API key in Braze, you can follow these steps:

* [Sign up](https://braze.com) or [Log in](https://braze.com) to your Braze account.
* Go to **Settings > API Keys**.
* Click **+ Create New API Key**.
* Give your new key a name for identification at a glance.
* Select the right permission you want to be associated with the new API key.

# Creating a Braze integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-braze) page on Novu.
* Click on `Add a Provider`.
* Locate **Braze** under the Email section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `API Key`.
* Enter the `Base URL`.
* Enter the `From email address`.
* Enter the `Sender name`.
* Click on the **Update** button.


# Infobip - email
Source: https://v0.x-docs.novu.co/channels-and-providers/email/infobip

Learn how to use the Infobip provider to send email notifications using Novu

You can use the [Infobip](https://www.infobip.com/developers/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Infobip provider in the email channel, you will need to create an Infobip account and add your API key and Base URL to the Infobip integration on the Novu platform.

# Generating an API Key

To generate a new API key in Infobip, you can follow these steps:

* [Sign up](https://www.infobip.com/signup) or [Log in](https://portal.infobip.com/login/) to your Infobip account.
* Navigate to the [Settings](https://portal.infobip.com/settings/accounts/api-keys) of your account and look for the API Keys section at the top of the settings page.

# Creating an Infobip integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-infobip) page on Novu.
* Click on Add a Provider.
* Select Infobip service.
* Enter your Infobip API Key.
* Enter your Base URL.
  * To see your base URL, log in to the account. Once logged in, on all pages, you should see your base URL in this format: `xxxxx.api.infobip.com`.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Infobip in Novu.


# Mailersend
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailersend

Learn how to use the MailerSend provider to send email notifications using Novu

[MailerSend](https://www.mailersend.com/) is an email delivery service that allows you to send emails from your application.

## Getting Started

To use the MailerSend provider in the email channel, you will need to create a MailerSend account and add your API key to the MailerSend integration on the Novu platform. To generate the API token go visit the [MailerSend API Tokens](https://www.mailersend.com/help/managing-api-tokens) page.

## Creating the MailerSend integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mailersend) page on Novu.
* Click on Add a Provider.
* Select MailerSend service.
* Enter the API key.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using MailerSend in Novu.

## Using MailerSend template

Novu has its own email editor for writing email template. If you want to use pre made template from MailerSend, you can use `customData` filed of email overrides to send template details. Make sure your `Api Key` has enough permission to read and process the template.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import {
      Novu
    } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.trigger("workflowIdentifier", {
      to: "subscriberId",
      payload: {},
      overrides: {
        email: {
          customData: {
            // mailersend template templateId
            templateId: 'mailersend-template-id',
            // mailersend template variables
            personalization: [{
              email: 'recipient@email.com',
              data: {
                items: {
                  price: '',
                  product: '',
                  quantity: '',
                },
                order: {
                  date: '',
                  order_number: '',
                  billing_address: '',
                  customer_message: '',
                },
                store: {
                  name: '',
                },
                invoice: {
                  total: '',
                  subtotal: '',
                  pay_method: '',
                },
                customer: {
                  name: '',
                  email: '',
                  phone: '',
                },
              },
            }, ],
          },
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl --location 'https://api.novu.co/v1/events/trigger' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <NOVU_API_KEY>' \
    --data '{
        "name": "workflowIdentifier",
        "to":  ["subscriberId"],
        "payload": {},
        "overrides": {
            "email": {
                "customData": {
                    "templateId": "mailersend-template-id",
                    "personalization": [{
                        "email": "recipient@email.com",
                        "data": {
                            "items": {
                                "price": "",
                                "product": "",
                                "quantity": ""
                            },
                            "order": {
                                "date": "",
                                "order_number": "",
                                "billing_address": "",
                                "customer_message": ""
                            },
                            "store": {
                                "name": ""
                            },
                            "invoice": {
                                "total": "",
                                "subtotal": "",
                                "pay_method": ""
                            },
                            "customer": {
                                "name": "",
                                "email": "",
                                "phone": ""
                            }
                        }
                    }]
                }
            }
        }
    }'
    ```
  </Tab>
</Tabs>


# Mailgun
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailgun

Learn how to use the Mailgun provider to send email notifications using Novu

You can use the [Mailgun](https://mailgun.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Mailgun provider in the email channel, you will need to create a Mailgun account and add your API key and domain name to the Mailgun integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mailgun, you can follow these steps:

* [Sign up](https://signup.mailgun.com/new/signup) or [Log in](https://login.mailgun.com/login/) to your Mailgun account.
* Click on the **Profile** section in the top right corner of the screen, and then click "API Keys" from the drop-down menu.
* On the [API Keys](https://app.mailgun.com/app/account/security/api_keys) page, copy the generated **Private API Key**

# Adding a new domain name

Mailgun recommends that you add a subdomain as a domain name. To do so:

* Visit the page to add a [domain name](https://app.mailgun.com/app/sending/domains/new).
  * During this process, you will need to choose a region for the domain name which is between `US` and `EU`. The default is `US`.
* Follow the [instructions](https://documentation.mailgun.com/en/latest/user_manual.html#verifying-your-domain-1) to verify the domain name.

# Creating a Mailgun integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mailgun) page on Novu.
* Click on Add a Provider.
* Select Mailgun service.
* Enter your Mailgun API Key.
* Enter your Base URL.
  * For domains created in the EU region, the base URL is: `https://api.eu.mailgun.net/`
  * Otherwise, leave the base URL blank.
* Fill in the `Username`.
* Fill in the `Domain name` registered on Mailgun.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Mailgun in Novu.


# Mailjet
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailjet

Learn how to use the Mailjet provider to send email notifications using Novu

You can use the [Mailjet](https://mailjet.com/) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the Mailjet provider in the email channel, you will need to create a Mailjet account and add your API key to the Mailjet integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mailjet, you can follow these steps:

* Log in to your Mailjet account.
* Click on **Settings** in the top-right corner of the screen, and then click **API KEYS & TRACKING** from the drop-down menu.
* On the API Keys page, click the **Create an API Key** button.
* Give the API key a name and choose the access level **Write and Read**
* Click the **Generate Key** button to create the new key. Once generated you can see the key but it will be hidden after the refresh

# Authenticating your sender identity

Before you can send emails on a large scale, you will need to authenticate your Sender identity. This is due to the latest regulatory changes regarding SPAM rules and email fraud. Most of the providers including Mailjet require you to authenticate your Sender identity before you can send emails.

Mailjet allows you to authenticate your sender identity using one of the following methods:

* [Single Sender Verification](https://dev.mailjet.com/email/guides/senders-and-domains/#sender-validation) - This is the easiest way to authenticate your sender identity.
* [Entire Domain Authentication](https://dev.mailjet.com/email/guides/senders-and-domains/#spf-and-dkim-validation) - This is recommended if you are sending emails from multiple accounts under your domain.

# Creating a Mailjet integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mailjet) page on Novu.
* Click on Add a Provider.
* Select Mailjet service.
* Enter your Mailjet API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Mailjet in Novu.


# Mailtrap
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailtrap

Learn how to use the Mailtrap provider to send email notifications using Novu

You can use the [Mailtrap](https://mailtrap.io/email-sending/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Mailtrap provider in the email channel, you will need to create a Mailtrap account and add your API key to the Mailtrap integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mailtrap, you can follow these steps:

* [Sign Up](https://mailtrap.io/register/signup) or [Log in](https://mailtrap.io/signin) to your Mailtrap account.
* Click on the **Email Sending** link on the sidebar, and then click the "Sending Domains" link that pops up from the available options.
* On the [Sending Domains](https://mailtrap.io/sending/domains) page, type your domain name and confirm with the `Add Your Domain` button. Then, proceed to copy DNS records Mailtrap provides to your domain’s DNS.
* Go to [API Keys](https://mailtrap.io/api-tokens) page and copy token with `Domain Admin` access level for your registered domain.

# Authenticating your Sender Identity

Before you can send emails, you will need to [verify your sending domain ownership](https://help.mailtrap.io/article/69-sending-domain-setup). Mailtrap rejects sending emails from unverified domains to prevent spam and email fraud.

# Creating a Mailtrap integration with Novu

* Visit the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-mailtrap) on the Novu web dashboard.
* Click on Add a Provider.
* Select Mailtrap service.
* Enter your Mailtrap API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications through Mailtrap using Novu.


# Mandrill
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mandrill

Learn how to use the Mandrill provider to send email notifications using Novu

You can use the [Mandrill by Mailchimp](https://mandrillapp.com/) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the Mandrill provider in the email channel, you will need to create a Mandrill account and add your API key to the Mandrill integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mandrill, you can follow these steps:

* [Sign up](https://login.mailchimp.com/signup/) or [Log in](https://login.mailchimp.com/) to your Mandrill account.
* Navigate to the [Settings](https://mandrillapp.com/settings) of your account and look for the API Keys section at the bottom of the settings page.
* Click on the **+ Add API Key** button to create an API key. Copy the generated key immediately and store it in a secure location. You won’t be able to see or copy the key once you finish generating it.

# Adding a sending domain

To get started, you’ll need to add the domain that you want to send messages from.

* Navigate to the [Settings page](https://mandrillapp.com/settings/sending-domains) and choose Domains
* Type a new domain in the domain input and click Add
* Follow the instructions to [verify ownership](https://mailchimp.com/developer/transactional/docs/authentication-delivery/#authentication) of your sending domain and [update your DNS records](https://mailchimp.com/developer/transactional/docs/authentication-delivery/#configure-your-dns).

# Creating the Mandrill integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mandrill) page on Novu.
* Click on Add a Provider.
* Select Mandrill service.
* Enter your Mandrill API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Mandrill in Novu.


# Netcore
Source: https://v0.x-docs.novu.co/channels-and-providers/email/netcore

Learn how to use the Netcore provider to send email notifications using Novu

You can use the [Netcore](https://netcorecloud.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Netcore provider in the email channel, you will need to create a Netcore account and add your API key to the Netcore integration on the Novu platform.

# Generating an API Key

To generate a new API key in Netcore, you can follow these steps:

* [Log in](https://email.netcorecloud.com/) to your Netcore account.
* Go to the **Integration** page under the **Settings** menu and click on the **API** tab.
* The API Key is hidden for security purposes. Click Show. The system will prompt you to enter your account password. Once you enter the password, the API key will be accessible.

# Setting up sending domains

To start sending emails, you need to add and verify your sending domains. You can either use your top-level domain (e.g. my-company.com) or a sub-domain like email.my-company.com. The verification is done to ensure your sending domain’s security.

Follow the instructions on this [page](https://emaildocs.netcorecloud.com/docs/what-is-a-sending-domain-how-to-set-up-sending-domains) to get started

# Creating a Netcore integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-netcore) page on Novu.
* Click on Add a Provider.
* Select Netcore service.
* Enter your Netcore API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Netcore in Novu.


# Outlook 365
Source: https://v0.x-docs.novu.co/channels-and-providers/email/outlook365

Learn how to use the Outlook 365 provider to send email notifications using Novu

You can use the [Outlook 365](https://office.com/) provider to send transactional emails through your instance of Office 365 to your customers using the Novu Platform with a single API.

## Getting Started

To use the Outlook 365 provider in the email channel, you will need to have the sender's email (user) and the password for the account. This account cannot be a shared mailbox or distribution list. It will need to be properly licensed to send email via Office 365.

## Creating the Outlook 365 integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-office365) page on Novu.
* Click on Add a Provider.
* Select Outlook service.
* Enter your SMTP credentials
  * `from`: The Complete email address of the sending user. (e.g. [jdoe@mycompany.com](mailto:jdoe@mycompany.com))
  * `senderName`: Sender Name should be the same email address of the sending user. (e.g. [jdoe@mycompany.com](mailto:jdoe@mycompany.com))
  * `password`: Password used to sign in with the email account.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Outlook 365 in Novu.

<Note> In order to create outlook integration, turn off multi factor authentication from account security settings.</Note>


# Email providers
Source: https://v0.x-docs.novu.co/channels-and-providers/email/overview

Learn the process of configuring email providers with Novu

Novu can be used to deliver email messages to your customers using a unified delivery API. You can easily integrate your favorite email provider using the built-in integration store.

<iframe />

## Configuring email providers

When creating an email provider integration you will be asked to provide additional fields alongside the provider-specific credentials:

* **Sender name** - Will be displayed as the sender of the message
* **From email address** - Emails sent using Novu will be sent using this address

For some email providers including SendGrid you will have to authenticate the **From email address** to make sure you will send email messages using an authorized address.

## Sending Email Overrides

The overrides field supports an email property. The email overrides field have properties like `to`, `from`, `senderName` etc

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        email: {
          to: ['to@novu.co'],
          from: 'from@novu.co',
          senderName: 'Novu Team',
          text: 'text version of email using overrides',
          replyTo: 'no-reply@novu.co',
          cc: ['1@novu.co'],
          bcc: ['2@novu.co'],
        },
      },
    });
    ```
  </Tab>
</Tabs>

<Note>It's very important to know that Novu merges the `to` field in the email overrides with the subscriber email. It DOES NOT REPLACE IT.</Note>

### Overriding the selected layout

Layout can be selected in the email step editor. To use another layout with emails, selected layout can be overridden using layoutIdentifier in the overrides field.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        layoutIdentifier: 'layout-identifier-value',
      },
    });
    ```
  </Tab>
</Tabs>

## Sending Email attachments

You can easily send attachments with the Novu API by passing the attachments array when triggering an Email based workflow. Attachment file can either be in the `buffer` or `base64` format.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      payload: {
        attachments: [
          {
            file: fs.readFileSync(__dirname + '/data/novu.jpeg'),
            name: 'novu.jpeg',
            mime: 'image/jpeg',
          },
        ],
      },
    });
    ```
  </Tab>
</Tabs>

## Using different email integration

In Novu integration store, multiple email channel type provider integrations can be active at the same time. But only one  provider integration can be primary at a time. This primary integration will be used as a provider to deliver the email by default. If you want to use a different active provider integration then you can use the `integrationIdentifier` email overrides field.

If there are 4 active email integrations with these identifiers:-

1. sendgrid-abcdef
2. sendgrid-ghijkl
3. brevo-abcdef
4. mailersend-abcdef

Here, if `sendgrid-abcdef` is primary integration and you want to use `brevo-abcdef` with this trigger then you can use `integrationIdentifier` email overrides field as below:-

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        email: {
          integrationIdentifier: "brevo-abcdef"
        },
      },
    });
    ```
  </Tab>
</Tabs>

<Info> Integration identifier is similar to Provider identifier but it is different than Provider Id. It is unique for each integration.You can find the `integrationIdentifier` in the integration store page.  </Info>

<Tip>
  <MissingProvider />
</Tip>


# Postmark
Source: https://v0.x-docs.novu.co/channels-and-providers/email/postmark

Learn how to use the Postmark provider to send email notifications using Novu

It is possible to use [Postmark](https://postmarkapp.com/) as a provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

The first step to use the Postmark provider in the email channel is to create a Postmark account and add the personal API key to the Postmark integration on the Novu platform.

# Getting the API Key

* To find the Postmark API key, log into the personal Postmark account and navigate to the servers page.
* After selecting the server to use, the API key (referred to as "Server API tokens") will be in the "API Tokens" section of the server chosen.

# Authenticating the sender's identity

Due to the latest regulatory changes regarding SPAM rules and email fraud, it is needed to authenticate the sender's identity before sending emails on a large scale. Most of the providers, including Postmark, require authentication to unlock the possibility of sending emails.

Postmark allows the authentication of the sender's identity using one of the following methods:

* [Single Sender Verification](https://account.postmarkapp.com/signatures/new) - This is the easiest way to authenticate the sender's identity.
* [Entire Domain Authentication](https://postmarkapp.com/support/article/1046-how-do-i-verify-a-domain#:~:text=be%20verified%20automatically.-,Navigate%20to%20Sender%20Signatures.,to%20your%20DNS%2C%20choose%20Verify.) - This is recommended for sending emails from multiple accounts under the same domain.

# Create a Postmark integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-postmark) page on Novu.
* Click on Add a Provider.
* Select Postmark service.
* Enter the Postmark API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* Now is possible to send notifications using Postmark in Novu.


# Introduction
Source: https://v0.x-docs.novu.co/channels-and-providers/in-app/introduction

Learn how to integrate In-App notification center and send In-App notification using Novu

In-app notifications are messages or alerts that appear within a mobile app or website while a user is actively using it. Unlike push notifications, which can reach users even when they're not actively engaged with an app, in-app notifications are designed to enhance the user experience within the app itself. Here's why they are important:

1. User Engagement: In-app notifications can keep users engaged and informed while they are using your app, providing valuable updates, reminders, or information relevant to their current activity. This can improve user satisfaction and encourage them to spend more time within the app.

2. Personalization: In-app notifications can be highly personalized based on a user's behavior, preferences, or location within the app. This personalization can lead to a more tailored and relevant user experience, increasing the likelihood of conversions or desired actions.

3. Onboarding and Education: In-app notifications are useful for guiding users through the app's features and functions, helping newcomers understand how to use the app effectively. They can also provide tips, tutorials, and educational content to enhance user proficiency.

4. Feedback and Surveys: In-app notifications can prompt users to provide feedback, complete surveys, or rate the app. Gathering user feedback within the app allows for real-time insights and improvements, contributing to app quality and user satisfaction.

5. Transactional Updates: In e-commerce or service apps, in-app notifications are crucial for providing order confirmations, shipping updates, payment receipts, and other transaction-related information, ensuring users are kept informed about important actions they've taken within the app.

6. Reduced Interruption: Unlike push notifications, in-app notifications are less intrusive since they only appear when users are actively engaged with the app. This can lead to a more seamless and focused user experience.

7. User Retention: By delivering timely and relevant information, in-app notifications can help retain users and reduce churn rates. Users who find value in the app are more likely to continue using it over time.

8. A/B Testing and Optimization: In-app notifications can be A/B tested to determine which messages and designs are most effective in achieving specific goals, such as increasing conversions or user engagement.

## In-app notifications using Novu

<iframe />

Novu provides a pre built component to display in-app notifications for almost all web frameworks. You can use this component to display in-app notifications in your web app. If you don't want to use the pre built component, you can use the headless component to build your own in-app notification center. Read more about notification center [here](/notification-center/introduction).


# Integration Store
Source: https://v0.x-docs.novu.co/channels-and-providers/integration-store

Learn about Novu's integration store

## Introduction

Novu's integration store serves as the central hub from where you can seamlessly enable and disable various services for efficient communication.

This feature simplifies the process of managing your communication channels. You can see which provider is enabled/disabled for what channel, which provider works in what environment and more. Moreover, it provides a clear overview of enabled and disabled services, offering you greater control over your communication strategy.

<Frame>
  <img />
</Frame>

From this image above, you can see that I've configured `Sendgrid` and `Twilio` as my email and sms provider respectively and both are in the `development` environment.

## Streamline Communication Services

With the Integration Store, you can streamline your communication services effortlessly. Whether it's Email, Chat, or SMS, this feature allows you to integrate different communication channels with ease. This centralization ensures that you can manage all your services conveniently from a single location.

## Enabling and Disabling Services

The Integration Store allows you to activate or deactivate specific services according to your communication needs. You can enable a service by simply entering the required `API key`, `identifier` and other required info depending on the provider you're choosing. Conversely, if you need to deactivate a service temporarily or make changes, you can disable it just as effortlessly.

## Enhanced Flexibility

By providing a comprehensive range of communication services under one roof, the Integration Store enhances your flexibility. You have the power to customize your communication strategy by enabling the services that align with your requirements.

## Conclusion

Novu's integration store offers a centralized and user-friendly platform for managing your communication services effectively. With its categorization, clear visibility, and easy enablement/disabling of services, you can fine-tune your communication strategy and streamline your interactions, enhancing the overall communication experience of your product.


# Overview
Source: https://v0.x-docs.novu.co/channels-and-providers/introduction

Learn about what channels, providers and oganizations are

## Channels:

Novu lets you send notifications across different communication mediums, including emails, in-app messages, push notifications, SMS, and chat. Each of these five communication mediums is referred to as a notification ‘channel’.

<Frame>
  <img />
</Frame>

## Providers:

Providers are what allow us to handle message delivery over multiple channels. Of the five notification channels that Novu currently supports, each channel except the ‘in-app’ channel has multiple providers.

The in-app channel only has one provider (the default Novu provider).

All the remaining channels have multiple providers.

## Organizations:

Organizations enable you to segregate notifications across multiple products that you may have. You can use Novu to send notifications across multiple apps and can create organizations.

<Frame>
  <img />
</Frame>

<Warning>Credentials are saved per instance of the active integrations of a provider. In case of more than one active provider of the same type, If `integrationIdentifier` is not sent in [this](https://docs.novu.co/api-reference/subscribers/update-subscriber-credentials) API, then the most recently created provider will be used to update the credentials.</Warning>


# Brand
Source: https://v0.x-docs.novu.co/content-creation-design/brand



Through Novu's web dashboard, you have the power to effortlessly tailor your brand settings, streamlining the process of creating notifications. Customize key elements such as your logo, which will be seamlessly integrated into your email communications.

For those utilizing Novu's In-App notification center, the ability to configure the primary font and its corresponding color awaits you. This empowers you to craft an experience for your users that resonates with your unique brand identity.

<img />


# Handlebars & Helpers
Source: https://v0.x-docs.novu.co/content-creation-design/handlebars-helpers



# Handlebars

The Novu notification content editor relies on Handlebars.js to establish the logic and control flow of our workflows.
For a deeper comprehension of Handlebars.js, you can refer to its [documentation](https://handlebarsjs.com/guide/#what-is-handlebars).

This resource offers comprehensive insights into the utilization of Handlebars.js in crafting dynamic and adaptable notification content within the Novu platform.

| Helper          | Description                                                                     | Example                                                          | Output                                                |
| --------------- | ------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ----------------------------------------------------- |
| if              | Conditionally renders a block. Falsy values won't be rendered.                  | `{{#if author}}<h1>{{firstName}} {{lastName}}</h1>{{/if}}`       | Renders `<h1>Yehuda Katz</h1>` if `author` is truthy. |
| includeZero     | `includeZero=true` treats the conditional as not empty, handling 0 differently. | `{{#if 0 includeZero=true}}<h1>Does render</h1>{{/if}}`          | Renders `<h1>Does render</h1>` for 0.                 |
| Sub-Expressions | Create custom logic helpers and use them in sub-expressions.                    | `{{#if (isdefined value1)}}true{{else}}false{{/if}}`             | Renders `true` or `false` based on custom helper.     |
| unless          | Inverse of if helper. Renders a block if the expression is falsy.               | `{{#unless license}}<h3 class="warning">WARNING</h3>{{/unless}}` | Renders warning if `license` is falsy.                |
| each            | Iterate over a list. Use this to reference the iterated element.                | `{{#each people}}<li>{{this}}</li>{{/each}}`                     | Renders list items.                                   |
| with            | Change context for template parts.                                              | `{{#with person}}{{firstname}} {{lastname}}{{/with}}`            | Renders `firstname` and `lastname` from the context.  |
| Nested each     | Access iteration variables in nested each blocks.                               | `{{#each array}}{{@index}}: {{this}}{{/each}}`                   | Renders index and item in each iteration.             |
| Nested with     | Use with block parameters for clear code.                                       | See above example with nested with and complex template.         | Renders nested context values.                        |
|                 | You can use else section to handle empty values.                                | `{{#with city}}...{{else}}No city found{{/with}}`                | Handles empty context case.                           |

# Novu-specific helpers

| Handlebar Expression                       | Description                                                                                                                                                                                                                           |
| ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `{{dateFormat date 'EEEE, MMMM Do yyyy'}}` | You can format the date using the `dateFormat` function. Here, `date: '2020-01-01'` has been formatted into `Wednesday, January 1st 2020`.                                                                                            |
| `{{lowercase key}}`                        | This helps you use the `lowercase` handlebar helper function and turns the value of the specified key to its lowercase value. So, for `message: 'hEllo WORLD'`, if we write `{{lowercase message}}`, we'll end up with `hello world`. |
| `{{uppercase key}}`                        | This helps you use the `uppercase` handlebar helper function and turns the value of the specified key to its uppercase value. So, for `message: 'hello woRld'`, if we write `{{uppercase message}}`, we'll end up with `HELLO WORLD`. |
| `{{titlecase key}}`                        | This helps you use the `titlecase` handlebar helper function and turns the value of the specified key to its titlecase value. So, for `message: 'hEllo wOrLD'`, if we write `{{titlecase message}}`, we'll end up with `Hello World`. |

### groupBy

`groupBy` helper is used to group the items in an array based on a property.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    {{#each (groupBy names "name")}}
      <h1>{{key}}<h1>
      {{#each items}}
        <h3>{{age}}</h3>
      {{/each}}
    {{/each}}
    ```
  </Tab>

  <Tab title="Context">
    ```json theme={null}
    {
      "names": [
        {
          "name": "Name 1",
          "age": "30"
        },
        {
          "name": "Name 2",
          "age": "31"
        },
        {
          "name": "Name 1",
          "age": "32"
        }
      ]
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
    <h1>Name 1<h1>
    <h3>30</h3>
    <h3>32</h3>
    <h1>Name 2<h1>
    <h3>31</h3>
    ```
  </Tab>
</Tabs>

### equals

`equals` helper allows you to perform comparisons, both for boolean expressions and string comparisons.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    <!-- LOGIC -->
    {{#equals value1 value2}}
       <!-- Code to execute when value1 is equal to value2 -->
    {{else}}
       <!-- Code to execute when value1 is not equal to value2 -->
    {{/equals}}


    <!-- Example -->
    {{#equals 10 1}}
       <h2> 10 is equal to 1 </h2>
    {{else}}
       <h1> 10 is not equal to 1 </h1>
    {{/equals}}
    ```
  </Tab>

  <Tab title="Context">
    ```json theme={null}
    {
      "value1" : 10,
      "values2" : 1
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
       <h1> 10 is not equal to 1 </h1>
    ```
  </Tab>
</Tabs>

### numberFormat

`numberFormat` helper is used to format numbers with specified decimal length, thousands separator, and decimal separator.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    <div>{{numberFormat number decimalSep="," decimalLength="2" thousandsSep="|"}}</div>
    <div>{{numberFormat nonNumber decimalSep="," decimalLength="2" thousandsSep="|"}}</div>
    ```
  </Tab>

  <Tab title="Context">
    ```json theme={null}
    {
      "number": 1000000000,
      "nonNumber": "Not a number"
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
    <div>1|000|000|000,00</div>
    <div>Not a number</div>
    ```
  </Tab>
</Tabs>

### pluralize

The `pluralize` helper allows you to easily handle pluralization in your templates by providing different forms of a word depending on a variable value.

### Basic Usage

In its simplest form, the `pluralize` helper takes three arguments:

```
{{pluralize count singular plural}}
```

* `count`: The numeric value that determines whether the singular or plural form should be used.
* `singular`: The singular form of the word.
* `plural`: The plural form of the word.

#### Example

```
{{pluralize dog_count "dog" "dogs"}}
```

In this example, if `dog_count` is equal to 1, it will render "1 dog," and if it's greater than 1, it will render "dogs."

## Use Cases & Examples

### Handling Event Count Display with Excluded Individuals

In some cases, you may want to display the total count of certain events but exclude specific individuals who are already mentioned. For example, when using a phrase like "John and `{{step.total_count}}` people liked your photo," you may notice that the count is off by one because "John" is already mentioned.

To account for such scenarios, you can utilize the following approach:

```
{{#each step.events}}
  {{#if @first}}
    {{this.name}}
  {{else}}
    {{#if @last}}
      and {{@index}}
    {{/if}}
  {{/if}}
{{/each}}
followed you!
```

In this code, we iterate through the `step.events` array and conditionally display each name. If it's the first name in the list, it will be shown without "and." For subsequent names, we add "and" before the last name. This ensures that the count is not affected by names that are explicitly mentioned in the message.

By using this code, you can achieve a more accurate representation of the event count in your messages, even when some users are individually mentioned in the message text.

### Using array length as count

Array length be used as total number of item. For example, if paylod have fruits property of type array then its length can be used as total number of fruits.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    Total number of fruits is {{fruits.length}}.
    ```
  </Tab>

  <Tab title="Payload">
    ```json theme={null}
    {
      "fruits": [
        {
          "name": "Pine apple",
          "price": "10$"
        },
        {
          "name": "Apple",
          "age": "8$"
        },
        {
          "name": "Orange",
          "age": "5$"
        }
      ]
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
    Total number of fruits is 3.
    ```
  </Tab>
</Tabs>

<Note> In a future release, we plan to replace handlebar helpers with an alternative solution. Please note that custom handlebars in the editor itself are not currently supported. If we are missing any handlebar helper that is blocking you to write template for use case, feel free to reach out to us in [discord](https://discord.gg/novu?ref=docs-handlebar-helper)</Note>


# Layouts
Source: https://v0.x-docs.novu.co/content-creation-design/layouts

Explore how to create and manage layouts in Novu

### Email Layouts

Novu allows the creation of layouts - a specific HTML design or structure to wrap content of email notifications. Layouts can be manipulated and assigned to new or existing workflows within the Novu platform, allowing users to create, manage, and assign these layouts to workflows, so they can be reused to structure the appearance of notifications sent through the platform.

By default, Novu will create a default layout and assign it as the organization's default layout. At any time, you can choose any of your layouts as the default for your organization. All new email templates will be assigned the default layout unless assigned a different one through the email editor.

#### Manage Layouts

You can find and manage your organization's layouts in `Brand -> Layouts`

<img />

#### Create and Edit Layouts

You can create new or edit existing layouts through the layout editor.

* You can create any html code to structure your layout.
* Set a layout as default for your organization. Notice there could only be one default layout at a time.
* Manage layout variables - set default values or required variables.

<img />

<Info> Layout content must include `{{{body}}}`, to indicate where the email editor content will be injected inside the layout. </Info>

#### Assign layout to workflow

To assign, choose a layout through the email editor. You can preview your layout combined with your email content through the `Preview` tab.

<img />

#### Override layout on trigger

To override your assigned layout during a trigger event, use the `layoutIdentifier` property.

The layout specified will be used for all emails in the context of that trigger event.

```ts theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

novu.trigger('workflow-identifier', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    attachments: [
      {
        file: fs.readFileSync(__dirname + '/data/test.jpeg'),
        name: 'test.jpeg',
        mime: 'image/jpg',
      },
    ],
  },
  overrides: {
    layoutIdentifier: 'your-layout-identifier',
  },
});
```

<Note> The override layout on trigger functionality is only available on v0.19.0.</Note>

#### Using SDK

Novu SDK supports all layout functionalities:

#### Create a new layout

A new layout can be created with name, description, content, variables and an `isDefault` flag. Here, content param is html content with custom variables.

```tsx theme={null}
const name: string = "layout-name";
const description: string =
  "The description of the layout that will help other users to understand the goal it was created"; // Optional.
const content: string = "<EMAIL_LAYOUT>";
const variables: ITemplateVariable[] = []; // Optional. Will handle the placeholder variables inserted in the email layout (content).
const isDefault: boolean = true; // Optional. All layouts are created as non default if not stated otherwise.

const { _id: layoutId } = await novu.layouts.create({
  name,
  description,
  content,
  variables,
  isDefault,
});
```

```tsx theme={null}
interface ITemplateVariable {
  type: TemplateVariableTypeEnum;
  name: string;
  required?: boolean;
  defaultValue?: string | boolean;
}

enum TemplateVariableTypeEnum {
  STRING = "String",
  ARRAY = "Array",
  BOOLEAN = "Boolean",
}
```

#### Update existing layout

When updating a layout, all properties are optional and the SDK will only update the ones passed.

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout.

const updatedLayout = await novu.layouts.update(layoutId, {
  name,
  description,
  content,
  variables,
  isDefault,
});
```

#### Set default layout

When executing this, the existing default layout in the environment will be automatically set as non default and the chosen layout will be set as default. This action is non reversible.

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout to be set as default.

await novu.layouts.setDefault(layoutId);
```

#### Delete an existing layout

Layouts can also be deleted. The condition to be able to delete a layout is that it is not a default layout and is not assigned in any existing workflow.

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout to be deleted.

await novu.layouts.delete(layoutId);
```

#### Get a layout

Find a layout by layoutId

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout to be found.

const layout = await novu.layouts.get(layoutId);
```

#### List all layouts

List paginated layouts

```tsx theme={null}
const page: number = 0; // Pagination value of the page for the results. First page will be page = 0.
const pageSize: number = 100; // Optional. Pagination value of the amount of layouts per page to return.
const sortBy: string = "createdAt"; // Optional. Property to order the list of the layouts. So far only `createdAt` is supported.
const orderBy: OrderDirectionEnum = -1; // Optional. Direction of the sorting by the property chosen in `sortBy`. Ascendent order is represented by 1 and descendent order is represented by -1.

const layouts = await novu.layouts.list({
  page,
  pageSize,
  sortBy,
  orderBy,
});
```

## API Reference Links

* [Layout Methods](/api-reference/layouts/layout-creation/)


# Content Creation
Source: https://v0.x-docs.novu.co/content-creation-design/notification-content-creation

Explore how to create notification content

To demonstrate the extensive range of possibilities, we've crafted a subscriber profile enriched with various attributes to highlight the flexibility of our system.

```typescript theme={null}
const subscriber = {
    subscriberId: '6427e97d0136cef86a315c46',
    firstName: 'John',
    lastName: 'Doe',
    email: 'john.doe@gmail.com',
    phone: '+98712345677',
    avatar: 'https://sm.ign.com/ign_nordic/cover/a/avatar-gen/avatar-generations_prsz.jpg',
    locale: 'en-US',
    data: {
        plan: 'basic',
        zipcode: 14925,
        validVehicleLicense: true
    }
};
```

Let's go over examples for each communication channel:

## Email

There are multiple ways to craft your email notification content for maximum impact.

<Note>
  Please remember that you have the option to preview the anticipated output of
  your input using the editor. Simply switch from the editing mode to the
  preview mode to see the results.
</Note>

### Regular Editor

Example: Send a personalized welcome email to a user by leveraging their properties.

**Input:**

```html theme={null}
Hello {{subscriber.firstName}} {{subscriber.lastName}}!

We are excited to welcome you to our {{subscriber.data.plan}} plan.
Look forward to receiving daily updates from us on your phone number: {{subscriber.phone}}.

{{#if subscriber.data.validVehicleLicense}}
Why not consider renting a car to visit us?
{{else}}
We're delighted to offer you a train ticket to come see us.
{{/if}}

Should you require any assistance, don't hesitate to reach out.
Best regards,
Your friends at Novu.
```

<img />

**Output:**

```html theme={null}
Hello John Doe!

We are excited to welcome you to our basic plan.
Look forward to receiving daily updates from us on your phone
number: +98712345677.

Why not consider renting a car to visit us?
Should you require any assistance, don't hesitate to reach out.
Best regards,
Your friends at Novu.
```

<img />

### Custom Code Editor

**Input:**

<Accordion title="Email Template Example">
  ```HTML theme={null}
  <!DOCTYPE html>
  <html>
  <head>
    <meta charset="UTF-8">
    <title>Welcome to Novu!</title>
    <style>
        /* Inline styles for email compatibility */
        body {
            font-family: 'Helvetica Neue', Arial, sans-serif;
            background-color: #f4f4f4;
            margin: 0;
            padding: 0;
        }
        .container {
            max-width: 600px;
            margin: 0 auto;
            padding: 20px;
            background-color: #ffffff;
            border-radius: 10px;
            box-shadow: 0 3px 6px rgba(0, 0, 0, 0.1);
        }
        .header {
            text-align: center;
            margin-bottom: 20px;
        }
        .message {
            font-size: 16px;
            line-height: 1.6;
            color: #333333;
            margin-bottom: 20px;
        }
        .cta-button {
            display: inline-block;
            padding: 10px 20px;
            background-color: #007bff;
            color: #ffffff;
            text-decoration: none;
            border-radius: 5px;
            font-weight: bold;
        }
        .signature {
            margin-top: 20px;
            font-style: italic;
            color: #888888;
        }
    </style>
  </head>
  <body>
    <div class="container">
        <div class="header">
            <h1 style="color: #007bff;">Welcome to Novu!</h1>
        </div>
        <div class="message">
            <p>Hello {{subscriber.firstName}} {{subscriber.lastName}}!</p>
            <p>We are thrilled to have you on board with our {{subscriber.data.plan}} plan.</p>
            <p>Get ready to receive daily updates on your phone: {{subscriber.phone}}.</p>
            <p>{{#if subscriber.data.validVehicleLicense}}
                We would like to offer you renting a car to visit us.
            {{else}}
                We would like to buy you a train ticket to visit us.
            {{/if}}</p>
            <p>If you need any assistance or have questions, feel free to reach out.</p>
            <p><a class="cta-button" href="#">Explore Your Options</a></p>
        </div>
        <div class="signature">
            <p>Best regards,<br>Your friends at Novu</p>
        </div>
    </div>
  </body>
  </html>
  ```
</Accordion>

<img />

**Output:**

<img />

<Info>Email Subject, Sender Name and Preheader field accepts system, payload variables and handlebar helpers</Info>
[Explore how to manage Email layouts.](/content-creation-design/layouts)

## In-App

The In-App notification content editor closely resembles the Email notification editor, although with some discernible differences.

<img />

You can:

* Transform notifications into clickable links, redirecting to your specified URLs
* Enjoy unlimited character freedom
* Utilize all variables to craft dynamic and personalized messages
* Infuse your brand's essence with customizable elements
* Drive engagement with action buttons
* Embed avatar images
* Preview the expected output

## SMS

When crafting your SMS notification, you can tap into all the available variables and even add dynamic ones.

<img />

## Chat

We make it effortless to send notifications to chat providers like Slack, Microsoft Teams, and Discord. Meet your users in the tools they use daily.
You have the ability to utilize all variables to craft dynamic and personalized messages.

<img />

## Push

Push channel has two fields `Push Message Title` and `Push Message Content` where user can write hard coded text content or use system, dynamic variables or handlebar helpers to customize notification content.

<img />


# Translations
Source: https://v0.x-docs.novu.co/content-creation-design/translations

Translate notification content to different languages using i18n.

<Info>The feature is only available for **Novu Cloud** users with **Business** or **Enterprise** plans.</Info>

## Introduction

The Translation Management feature allows you to seamlessly adapt your workflows to different languages and automatically apply them based on your customers' locales. It enhances engagement, personalizes the user experience, and allows you to expand your market reach.

To understand how Translation Management works in Novu we need to review its main pillars:

* Translation Groups
* Translation Files
* Localized Message Content
* Subscribers locale

## Translation Groups

Translation Group allows you to efficiently manage translations for diverse languages with shared business significance. For example, the Branding translation group can hold the content related to your company identity, while the Marketing translation group can exclusively house content related to your marketing campaigns. You aren't obligated to divide your translation content, you can manage it all within a single translation group.

To create the Translation Group navigate to the `Translations` page from the main navigation and click on the “Add group” button.

<img />

Before creating your first Translation Group you'll be prompted to specify the default locale for organization. This locale serves as a fallback option for localized messages in cases where the recipient hasn't defined a specific locale.

<img />

After selecting the default language, you can provide the essential details: the group name, group identifier, and select your target languages.

The group identifier is an important value that you will later use in the editor to localize your messages. This is a similar concept that we use across the app to identify the main parts.

<img />

After the group is created, you will land on the group details page on which you can see the list with the empty translations for the languages you choose.

<img />

## Translations

Translations are JSON files that contain the content of your messages in a specific language. For example, if you created a Marketing translation group with two target languages English and German, then your translation JSON files might look like this:

**English (en.json):**

```json theme={null}
{
  "welcome_message": "Welcome to our Marketing Campaign!",
  "learn_more": "Learn More",
  "special_offer": "Special Offer",
  "contact_us": "Contact Us"
}
```

**German (de.json):**

```json theme={null}
{
  "welcome_message": "Willkommen bei unserer Marketingkampagne!",
  "learn_more": "Mehr erfahren",
  "special_offer": "Sonderangebot",
  "contact_us": "Kontaktieren Sie uns"
}
```

To upload your translations click on the “Upload files” button located at the top of the Translation Group details page.

<img />

Select the translation files and click “Open” button.

<img />

With each uploaded translation file, you must indicate the language it references. Additionally, you can verify the correctness of the uploaded file by previewing its contents.

<img />

Click on “Upload files” button. Congratulations you just uploaded the translation files and created the translation group! 🎉

### Localized Message Content

To localize your message content, you need to use the translation variables in the editor. The variables allow you to reference the values from the translation files. It consists of the `i18n` [handlebar](https://docs.novu.co/content-creation-design/handlebars-helpers) helper and path to the translated value.

Let’s take a look at the example: `{{i18n "marketing.welcome_message"}}`.

* `i18n` is the handlebar helper that tells Novu that you would like to use the Translations
* `"marketing.welcome_message"` is the path that is composed of the Translation Group identifier `marketing` and translation JSON file key `welcome_message`

<img />

<Info>i18n variables can be used in `subject` and `preheader` fields of the email step.</Info>

## Subscribers Locale

The subscribers locale defines in which language the message should be delivered to that recipient. When the locale is not specified it will fallback to the default locale set for the organization. The locale format includes ISO language plus the region, for example `de_DE` language German and region Germany.

To update the locale you can use Novu API or any of our SDKs, more information can be found [here](https://docs.novu.co/subscribers/subscribers).

## Editor Examples

### Variables

It is possible to include variables in your translation strings, they should be wrapped in double curly brackets. Their value could be set as a string or as a variable - either a system variable or a variable sent through the payload.

```json theme={null}
{
  "withVariables": "Welcome {{name}} to {{organization}}"
}
```

In the editor:

```handlebars theme={null}
{{i18n "welcome.withVariables" name=subscriber.firstName organization="Novu"}}
```

### Context

By providing a context you can differ translations. Eg. useful to provide gender specific translations.

For example:

```json theme={null}
{
	"friend": "A friend",
	"friend_male": "A boyfriend",
	"friend_female": "A girlfriend"
}
```

In the editor:

```handlebars theme={null}
{{i18n "welcome.friend" context="male"}}
```

Will result in the message `A boyfriend`. Not adding any context will output `A friend`.

### Plurals

To distinguish between plural translation options.

```json theme={null}
{
	"keyWithCount": "{{count}} item",
	"keyWithCount_plural": "{{count}} items",
}
```

In the editor:

```handlebars theme={null}
{{i18n "welcome.keyWithCount" count=7}}
```

Will result in `7 items`

### Date formats

To control date formats, do as follows:

```json theme={null}
{
  "date": "Current date: {{date, dd/MM/yyyy}}",
  "try_date": "Current date: {{date, MM/dd/yyyy}}",
  "intlDateTime": "On the {{date, HH:yyyy}}"
}
```

In the editor:

<Tip>
  Date can be a string or a variable you send in the payload as `{ date: new Date() }`
</Tip>

```handlebars theme={null}
{{i18n "welcome.date" date="12-06-2023"}}
{{i18n "welcome.try_date" date=date}}
{{i18n "welcome.intlDateTime" date=date}}
```


# Workflow Editor
Source: https://v0.x-docs.novu.co/content-creation-design/variables



Novu's content creation tools allow developers to utilize a wealth of variables when designing notification workflows.

As developers construct workflows using Novu, certain status facets—results of batch functions and other steps in the workflow—are auto-generated and can be utilized to control the content displayed in notification templates.

These variables offer dynamic and automated properties that hold subscriber information, such as first and last name, email, phone, and avatar.

For example, developers can insert a subscriber's first name into a workflow by using `{{ subscriber.firstName }}`.

In addition to the subscriber's details, developers can use data payload variables that encapsulate dynamic data meant to be injected into the content of a workflow.

For instance, in the code example the variables username and resetLink are data payload variables that would be adjusted based on the workflow's purpose.

**The utilization of these variables allows Novu to deliver personalized notifications to the receiver, thus improving user experience and accomplishing better communication outcomes.**

## System Variables

### Subscriber Variables

| Variable       | Type     | Description                                                                   |
| -------------- | -------- | ----------------------------------------------------------------------------- |
| `subscriber`   | `Object` | Represents someone who is intended to receive a notification.                 |
| `firstName`    | `String` | The first name of the subscriber.                                             |
| `lastName`     | `String` | The last name of the subscriber.                                              |
| `email`        | `String` | The subscriber's email address.                                               |
| `phone`        | `String` | The phone number associated with the subscriber.                              |
| `avatar`       | `String` | A URL or reference to the subscriber’s avatar or profile picture.             |
| `locale`       | `String` | The preferred locale or language of the subscriber.                           |
| `subscriberId` | `String` | Unique identifier for the subscriber.                                         |
| `data`         | `Object` | An additional object that can hold custom subscriber data as key-value pairs. |

### Actor Variables

| Variable       | Type     | Description                                                              |
| -------------- | -------- | ------------------------------------------------------------------------ |
| `actor`        | `Object` | A subscriber who initiates actions triggering events.                    |
| `firstName`    | `String` | The first name of the actor.                                             |
| `lastName`     | `String` | The last name of the actor.                                              |
| `email`        | `String` | The actor's email address.                                               |
| `phone`        | `String` | The phone number associated with the actor.                              |
| `avatar`       | `String` | A URL or reference to the actor’s avatar or profile picture.             |
| `locale`       | `String` | The preferred locale or language of the actor.                           |
| `subscriberId` | `String` | Unique identifier for the actor.                                         |
| `data`         | `Object` | An additional object that can hold custom actor data as key-value pairs. |

### Step Variables

| Variable      | Type      | Description                                                                 |
| ------------- | --------- | --------------------------------------------------------------------------- |
| `step`        | `Object`  | A component in the execution of a workflow.                                 |
| `digest`      | `Boolean` | Indicates whether digest mode is active or not.                             |
| `events`      | `Array`   | An aggregated collection of events (that are stored when digest is active). |
| `total_count` | `Number`  | Represents the total number of events in the digest.                        |

### Brand Variables

| Variable   | Type     | Description                                                                 |
| ---------- | -------- | --------------------------------------------------------------------------- |
| `branding` | `Object` | Enables customization of the notification's visual identity.                |
| `logo`     | `String` | Insert the brand logo.                                                      |
| `color`    | `String` | Set the primary color of the notification based on the brand configuration. |

### Tenant Variables

| Variable | Type     | Description                                                               |
| -------- | -------- | ------------------------------------------------------------------------- |
| `tenant` | `Object` | Group of users or an organization.                                        |
| `name`   | `String` | Insert the brand logo.                                                    |
| `data`   | `Object` | An additional object that can hold custom tenant data as key-value pairs. |

## Data Payload Variables

Data payload variables encompass the dynamic data intended to be injected into the content of a workflow. These variables are integral components of the payload object, forming part of the parameters for the trigger function.

Here's a more illustrative example of how data payload variables can be employed:

```jsx theme={null}
curl -L -X POST 'https://api.novu.co/v1/events/trigger' \
-H 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
-H 'Content-Type: application/json' \
--data-raw '{
    "name": "password-reset",
    "to": {
        "subscriberId": "6427e97d0136cef86a315c46",
        "email": "john.doe@acme.com"
    },
    "payload": {
        "username": "Jhontheman1969",
        "resetLink": "http://sample.info/password.reset",
        "securityEmail": "john.doe.backup@acme.com",
    }
}'
```

Within this code snippet, the variables `username` and `resetLink` are representative of data payload variables.

Importantly, it's worth noting that the payload itself can encompass any serializable JSON object.

<Info>Avoid use of system reserved variables as normal variables. For example don't use `email` as variable name because `{{subscriber.email}}` is a system reserved variable</Info>


# Concepts
Source: https://v0.x-docs.novu.co/getting-started/concepts

Learn about the key concepts of Novu

## Notification

A notification conveys information from source to recipient, triggered by a workflow acting as a message blueprint. Notifications can be individual or bundled as [digest](/workflows/digest) for user-friendliness.

## Messages

A message in Novu represents a notification delivered to a recipient on a particular channel. Messages contain information about the request that triggered its delivery, a view of the data sent to the recipient, and a timeline of its lifecycle events. [Learn more about messages](/workflows/messages).

## Workflow

All notifications are sent via a workflow. Each workflow acts as a container for the logic and blueprint that are associated with a type of notification in your system. [Learn more](/workflows/notification-workflows)

## Channel

A channel in Novu represents a configured provider, such as Sendgrid for email, to send notifications to your recipients. A channel is the communication-context domain with the recipients (subscribers).

Most providers within Novu use credentials that you supply to deliver notifications on your behalf. These credentials and other settings are what make a configured channel. [Learn more](/channels-and-providers/introduction)

## Subscriber

A subscriber in Novu represents someone who should receive a message. A subscriber's profile information contains important attributes about the subscriber that will be used in messages (name, email). The subscriber object can contain other key-value pairs that can be used to further personalize your messages. [Learn more about subscribers.](/subscribers/subscribers)

## Topics

Topics are a way to group subscribers together so that they can be notified of events at once. A topic is identified by a custom key. This can be helpful for things like sending out marketing emails or notifying users of new features. Topics can also be used to send notifications to the subscribers who have been grouped together based on their interests, location, activities and much more. [Learn more about topics.](/subscribers/topics)

## Activity Feed

Novu provides a notification activity feed that monitors every outgoing message associated with its relevant metadata. This can be used to monitor activity and discover potential issues with a specific provider or a channel type. [Learn more about the activity feed.](/activity-feed/introduction)

## Integration Store

With the help of the integration store, you can easily integrate your favorite delivery provider. During the runtime of the API, the Integrations Store is responsible for storing the configurations of all the providers. [Learn more](/channels-and-providers/integration-store)

## Providers

Providers are the channel service providers (Twilio, Sendgrid, APN, etc,) you connect to Novu so that it can send your notifications. Rather than replacing your existing providers, Novu passes your notifications to the providers you already use via these channel integrations. [Learn more about providers.](/channels-and-providers/introduction)

## Environment

* Production
* Development

Novu uses the concept of environments to ensure logical separation of your data and configuration. This means that subscribers, and preferences created in one environment are **never** accessible to another. [Learn more about environments.](/platform/environments)

## Handlebars & Helpers

Handlebars is a simple templating language that generates HTML.

Novu-specific Helpers make it possible to define custom iterators and other functionality that can invoke the passed block with a new context. [Learn more about helpers.](/content-creation-design/handlebars-helpers)

## Organization

An organization serves as a separate entity within your Novu account. Each organization you create has its own separate integration store, workflows, subscribers, and API keys. This separation of resources allows you to manage multi-tenant environments and separate domains within a single account.

Switching your organization in the UI only affects the UI and does not deactivate any organizations on the API side. Moreover, the message delivery for each organization operates simultaneously.

Keep in mind that workflows and integration stores for one organization cannot be used for subscribers of other organizations.

<img />

To create a new organization, you interact with a drop down menu in the bottom of the left navigation bar within Novu’s application. Type the name of your new organization, and if the name is new, you will see a button that enables you to add a new one.

<img />

To switch between organizations, you again interact with the same drop down menu and switch between the organizations you have in your Novu account.

<img />

## Notification Center

Notification Center is a beautifully designed and highly functional in-app experience for your users that you can add to your product quickly and effortlessly.

The core components of our Notification Center are:

* A list of notifications with real-time updates
* Notification preference management
* State management and actions for notifications (mark as read/unread, and delete)
* And more

[Learn more](/notification-center/introduction)

## Preference

A preference indicates a user's willingness to receive a particular type of notification. Preferences always belong to a user and can be paired with an identifier that represents the account or tenant that the user belongs to (for multi-tenant applications). [Learn more](/subscribers/preferences)

## Delay Actions

The delay action awaits a specified amount of time before moving on to trigger the following steps of the workflow. [Learn more](/workflows/delay-action)

## Digest

The digest engine collects multiple trigger events, aggregates them into a single message and delivers it to the subscriber. [Learn more](/workflows/digest)

## Layouts

Novu allows the creation of layouts - a specific HTML design or structure to wrap content of email notifications. Layouts can be manipulated and assigned to new or existing workflows within the Novu platform, allowing users to create, manage, and assign these layouts to workflows, so they can be reused to structure the appearance of notifications sent through the platform. [Learn more](/content-creation-design/layouts)

## Tenants

A tenant represents a group of users. As a developer, when your apps have organizations, they are referred to as tenants. Tenants in Novu provides the ability to tailor specific notification experiences to users of different **groups** or **organizations**. [Learn more about Novu Tenants.](/tenants/introduction)


# How Does Novu Work?
Source: https://v0.x-docs.novu.co/getting-started/how-novu-works



Novu comprises two fundamental components: an API for data exchange and a dashboard for designing notifications and their accompanying logical rules.

This section provides a broad overview of Novu's functionality, delving into key concepts for your initial Novu journey. If you prefer to dive into development, explore our **[Quick Start guides](/quickstarts/overview)**.

## Architecture

Novu's Object Communication Layer (OCL) is a structured framework that separates communication tasks into specialized components.
Similar to microservices, these components handle specific roles like message passing and data management. By doing so, OCL enhances system maintenance and scalability, making it easier to integrate new functionalities.

Novu's approach goes beyond this, optimizing communication protocols for seamless collaboration and adaptability. It's like providing a playbook for coordinating a dynamic game, ensuring all players are synchronized for any challenge.

<img />


# What is Novu?
Source: https://v0.x-docs.novu.co/getting-started/introduction

Novu is a full-stack (UI, API & GitOps) open source notification infrastructure tool and platform for building, managing, delivering, and monitoring all types of end-user notifications.

Novu supports a variety of common notification channels out-of-the-box, including **email**, **SMS**, **push**, **in-app**, and **chat**. Our platform is a developer-first product built for engineers that need to simplify the complexities of notification management, while working closely with product and marketing teams that need to provide, edit, and maintain notification content.

<AccordionGroup>
  <Accordion title="Get started with our quickstarts">
    Get started in minutes

    <CardGroup>
      <Card title="React" icon="react" href="/quickstarts/react">
        Embed a real-time notification center component in your React application.
      </Card>

      <Card title="Vue" icon="vuejs" href="/quickstarts/vue">
        Embed a real-time notification center component in your Vue application.
      </Card>

      <Card title="Angular" icon="angular" href="/quickstarts/angular">
        Embed a real-time notification center component in your Angular application.
      </Card>

      <Card
        title="Kotlin"
        icon={
<svg
    xmlns="http://www.w3.org/2000/svg"
    width="20"
    height="20"
    viewBox="0 0 256 256"
  >
    <defs>
      <linearGradient
        id="logosKotlinIcon0"
        x1="99.991%"
        x2=".01%"
        y1="-.011%"
        y2="100.01%"
      >
        <stop offset=".344%" stopColor="#E44857" />
        <stop offset="46.89%" stopColor="#C711E1" />
        <stop offset="100%" stopColor="#7F52FF" />
      </linearGradient>
    </defs>
    <path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosKotlinIcon0)" d="M256 256H0V0h256L128 127.949z" />
  </svg>}
        href="/quickstarts/kotlin"
      >
        Embed a real-time notification center component in your Kotlin application.
      </Card>

      <Card
        title="PHP"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#deviconPhp0)" d="M0 64c0 18.593 28.654 33.667 64 33.667c35.346 0 64-15.074 64-33.667c0-18.593-28.655-33.667-64-33.667C28.654 30.333 0 45.407 0 64Z"/><path fill="#777bb3" d="M64 95.167c33.965 0 61.5-13.955 61.5-31.167c0-17.214-27.535-31.167-61.5-31.167S2.5 46.786 2.5 64c0 17.212 27.535 31.167 61.5 31.167Z"/><path d="M34.772 67.864c2.793 0 4.877-.515 6.196-1.53c1.306-1.006 2.207-2.747 2.68-5.175c.44-2.27.272-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.464l-2.473 12.732zM20.173 83.547a.694.694 0 0 1-.68-.828l6.557-33.738a.695.695 0 0 1 .68-.561h14.134c4.442 0 7.748 1.206 9.827 3.585c2.088 2.39 2.734 5.734 1.917 9.935c-.333 1.711-.905 3.3-1.7 4.724a15.818 15.818 0 0 1-3.128 3.92c-1.531 1.432-3.264 2.472-5.147 3.083c-1.852.604-4.232.91-7.07.91h-5.724l-1.634 8.408a.695.695 0 0 1-.682.562z"/><path fill="#fff" d="M34.19 55.826h3.891c3.107 0 4.186.682 4.553 1.089c.607.674.723 2.097.331 4.112c-.439 2.257-1.253 3.858-2.42 4.756c-1.194.92-3.138 1.386-5.773 1.386h-2.786l2.205-11.342zm6.674-8.1H26.731a1.39 1.39 0 0 0-1.364 1.123L18.81 82.588a1.39 1.39 0 0 0 1.363 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.151c2.912 0 5.364-.318 7.287-.944c1.977-.642 3.796-1.731 5.406-3.237a16.522 16.522 0 0 0 3.259-4.087c.831-1.487 1.429-3.147 1.775-4.931c.86-4.423.161-7.964-2.076-10.524c-2.216-2.537-5.698-3.823-10.349-3.823zM30.301 68.557h4.471c2.963 0 5.17-.557 6.62-1.675c1.451-1.116 2.428-2.98 2.938-5.591c.485-2.508.264-4.277-.665-5.308c-.931-1.03-2.791-1.546-5.584-1.546h-5.036l-2.743 14.12m10.563-19.445c4.252 0 7.353 1.117 9.303 3.348c1.95 2.232 2.536 5.347 1.76 9.346c-.322 1.648-.863 3.154-1.625 4.518c-.764 1.366-1.76 2.614-2.991 3.747c-1.468 1.373-3.097 2.352-4.892 2.935c-1.794.584-4.08.875-6.857.875h-6.296l-1.743 8.97h-7.35l6.558-33.739h14.133"/><path d="M69.459 74.577a.694.694 0 0 1-.682-.827l2.9-14.928c.277-1.42.209-2.438-.19-2.87c-.245-.263-.979-.704-3.15-.704h-5.256l-3.646 18.768a.695.695 0 0 1-.683.56h-7.29a.695.695 0 0 1-.683-.826l6.558-33.739a.695.695 0 0 1 .682-.561h7.29a.695.695 0 0 1 .683.826L64.41 48.42h5.653c4.307 0 7.227.758 8.928 2.321c1.733 1.593 2.275 4.14 1.608 7.573l-3.051 15.702a.695.695 0 0 1-.682.56h-7.407z"/><path fill="#fff" d="M65.31 38.755h-7.291a1.39 1.39 0 0 0-1.364 1.124l-6.557 33.738a1.39 1.39 0 0 0 1.363 1.654h7.291a1.39 1.39 0 0 0 1.364-1.124l3.537-18.205h4.682c2.168 0 2.624.463 2.641.484c.132.14.305.795.019 2.264l-2.9 14.927a1.39 1.39 0 0 0 1.364 1.654h7.408a1.39 1.39 0 0 0 1.363-1.124l3.051-15.7c.715-3.686.103-6.45-1.82-8.217c-1.836-1.686-4.91-2.505-9.398-2.505h-4.81l1.421-7.315a1.39 1.39 0 0 0-1.364-1.655zm0 1.39l-1.743 8.968h6.496c4.087 0 6.907.714 8.457 2.14c1.553 1.426 2.017 3.735 1.398 6.93l-3.052 15.699h-7.407l2.901-14.928c.33-1.698.208-2.856-.365-3.474c-.573-.617-1.793-.926-3.658-.926h-5.829l-3.756 19.327H51.46l6.558-33.739h7.292z"/><path d="M92.136 67.864c2.793 0 4.878-.515 6.198-1.53c1.304-1.006 2.206-2.747 2.679-5.175c.44-2.27.273-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.463l-2.475 12.732zM77.54 83.547a.694.694 0 0 1-.682-.828l6.557-33.738a.695.695 0 0 1 .682-.561H98.23c4.442 0 7.748 1.206 9.826 3.585c2.089 2.39 2.734 5.734 1.917 9.935a15.878 15.878 0 0 1-1.699 4.724a15.838 15.838 0 0 1-3.128 3.92c-1.53 1.432-3.265 2.472-5.147 3.083c-1.852.604-4.232.91-7.071.91h-5.723l-1.633 8.408a.695.695 0 0 1-.683.562z"/><path fill="#fff" d="M91.555 55.826h3.891c3.107 0 4.186.682 4.552 1.089c.61.674.724 2.097.333 4.112c-.44 2.257-1.254 3.858-2.421 4.756c-1.195.92-3.139 1.386-5.773 1.386h-2.786l2.204-11.342zm6.674-8.1H84.096a1.39 1.39 0 0 0-1.363 1.123l-6.558 33.739a1.39 1.39 0 0 0 1.364 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.15c2.911 0 5.364-.318 7.286-.944c1.978-.642 3.797-1.731 5.408-3.238a16.52 16.52 0 0 0 3.258-4.086c.832-1.487 1.428-3.147 1.775-4.931c.86-4.423.162-7.964-2.076-10.524c-2.216-2.537-5.697-3.823-10.35-3.823zM87.666 68.557h4.47c2.964 0 5.17-.557 6.622-1.675c1.45-1.116 2.428-2.98 2.936-5.591c.487-2.508.266-4.277-.665-5.308c-.93-1.03-2.791-1.546-5.583-1.546h-5.035Zm10.563-19.445c4.251 0 7.354 1.117 9.303 3.348c1.95 2.232 2.537 5.347 1.759 9.346c-.32 1.648-.862 3.154-1.624 4.518c-.763 1.366-1.76 2.614-2.992 3.747c-1.467 1.373-3.097 2.352-4.892 2.935c-1.793.584-4.078.875-6.856.875h-6.295l-1.745 8.97h-7.35l6.558-33.739h14.133"/><defs><radialGradient id="deviconPhp0" cx="0" cy="0" r="1" gradientTransform="translate(38.426 42.169) scale(84.04136)" gradientUnits="userSpaceOnUse"><stop stopColor="#AEB2D5"/><stop offset=".3" stopColor="#AEB2D5"/><stop offset=".75" stopColor="#484C89"/><stop offset="1" stopColor="#484C89"/></radialGradient></defs></svg>
}
        href="/quickstarts/php"
      >
        Embed a real-time notification center component in your PHP application.
      </Card>

      <Card
        title="Ruby"
        icon={<svg xmlns="http://www.w3.org/2000/svg" width="20" height="19.93" viewBox="0 0 256 255"><defs><linearGradient id="logosRuby0" x1="84.75%" x2="58.254%" y1="111.399%" y2="64.584%"><stop offset="0%" stopColor="#FB7655"/><stop offset="0%" stopColor="#FB7655"/><stop offset="41%" stopColor="#E42B1E"/><stop offset="99%" stopColor="#900"/><stop offset="100%" stopColor="#900"/></linearGradient><linearGradient id="logosRuby1" x1="116.651%" x2="1.746%" y1="60.89%" y2="19.288%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby2" x1="75.774%" x2="38.978%" y1="219.327%" y2="7.829%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby3" x1="50.012%" x2="66.483%" y1="7.234%" y2="79.135%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E57252"/><stop offset="46%" stopColor="#DE3B20"/><stop offset="99%" stopColor="#A60003"/><stop offset="100%" stopColor="#A60003"/></linearGradient><linearGradient id="logosRuby4" x1="46.174%" x2="49.932%" y1="16.348%" y2="83.047%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E4714E"/><stop offset="56%" stopColor="#BE1A0D"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby5" x1="36.965%" x2="49.528%" y1="15.594%" y2="92.478%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="18%" stopColor="#E46342"/><stop offset="40%" stopColor="#C82410"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby6" x1="13.609%" x2="85.764%" y1="58.346%" y2="-46.717%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="54%" stopColor="#C81F11"/><stop offset="99%" stopColor="#BF0905"/><stop offset="100%" stopColor="#BF0905"/></linearGradient><linearGradient id="logosRuby7" x1="27.624%" x2="50.745%" y1="21.135%" y2="79.056%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="31%" stopColor="#DE4024"/><stop offset="99%" stopColor="#BF190B"/><stop offset="100%" stopColor="#BF190B"/></linearGradient><linearGradient id="logosRuby8" x1="-20.667%" x2="104.242%" y1="122.282%" y2="-6.342%"><stop offset="0%" stopColor="#BD0012"/><stop offset="0%" stopColor="#BD0012"/><stop offset="7%" stopColor="#FFF"/><stop offset="17%" stopColor="#FFF"/><stop offset="27%" stopColor="#C82F1C"/><stop offset="33%" stopColor="#820C01"/><stop offset="46%" stopColor="#A31601"/><stop offset="72%" stopColor="#B31301"/><stop offset="99%" stopColor="#E82609"/><stop offset="100%" stopColor="#E82609"/></linearGradient><linearGradient id="logosRuby9" x1="58.792%" x2="11.964%" y1="65.205%" y2="50.128%"><stop offset="0%" stopColor="#8C0C01"/><stop offset="0%" stopColor="#8C0C01"/><stop offset="54%" stopColor="#990C00"/><stop offset="99%" stopColor="#A80D0E"/><stop offset="100%" stopColor="#A80D0E"/></linearGradient><linearGradient id="logosRubya" x1="79.319%" x2="23.088%" y1="62.754%" y2="17.888%"><stop offset="0%" stopColor="#7E110B"/><stop offset="0%" stopColor="#7E110B"/><stop offset="99%" stopColor="#9E0C00"/><stop offset="100%" stopColor="#9E0C00"/></linearGradient><linearGradient id="logosRubyb" x1="92.88%" x2="59.841%" y1="74.122%" y2="39.704%"><stop offset="0%" stopColor="#79130D"/><stop offset="0%" stopColor="#79130D"/><stop offset="99%" stopColor="#9E120B"/><stop offset="100%" stopColor="#9E120B"/></linearGradient><linearGradient id="logosRubyc" x1="56.57%" x2="3.105%" y1="101.717%" y2="11.993%"><stop offset="0%" stopColor="#8B2114"/><stop offset="0%" stopColor="#8B2114"/><stop offset="43%" stopColor="#9E100A"/><stop offset="99%" stopColor="#B3100C"/><stop offset="100%" stopColor="#B3100C"/></linearGradient><linearGradient id="logosRubyd" x1="30.87%" x2="92.471%" y1="35.599%" y2="100.694%"><stop offset="0%" stopColor="#B31000"/><stop offset="0%" stopColor="#B31000"/><stop offset="44%" stopColor="#910F08"/><stop offset="99%" stopColor="#791C12"/><stop offset="100%" stopColor="#791C12"/></linearGradient><radialGradient id="logosRubye" cx="32.001%" cy="40.21%" r="69.573%" fx="32.001%" fy="40.21%"><stop offset="0%" stopColor="#A80D00"/><stop offset="0%" stopColor="#A80D00"/><stop offset="99%" stopColor="#7E0E08"/><stop offset="100%" stopColor="#7E0E08"/></radialGradient><radialGradient id="logosRubyf" cx="13.549%" cy="40.86%" r="88.386%" fx="13.549%" fy="40.86%"><stop offset="0%" stopColor="#A30C00"/><stop offset="0%" stopColor="#A30C00"/><stop offset="99%" stopColor="#800E08"/><stop offset="100%" stopColor="#800E08"/></radialGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby0)" d="m197.467 167.764l-145.52 86.41l188.422-12.787L254.88 51.393l-57.414 116.37Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby1)" d="M240.677 241.257L224.482 129.48l-44.113 58.25l60.308 53.528Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby2)" d="m240.896 241.257l-118.646-9.313l-69.674 21.986l188.32-12.673Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby3)" d="m52.744 253.955l29.64-97.1L17.16 170.8l35.583 83.154Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby4)" d="M180.358 188.05L153.085 81.226l-78.047 73.16l105.32 33.666Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby5)" d="m248.693 82.73l-73.777-60.256l-20.544 66.418l94.321-6.162Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby6)" d="M214.191.99L170.8 24.97L143.424.669l70.767.322Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby7)" d="m0 203.372l18.177-33.151l-14.704-39.494L0 203.372Z"/><path fill="#FFF" d="m2.496 129.48l14.794 41.963l64.283-14.422l73.39-68.207l20.712-65.787L143.063 0L87.618 20.75c-17.469 16.248-51.366 48.396-52.588 49c-1.21.618-22.384 40.639-32.534 59.73Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby8)" d="M54.442 54.094c37.86-37.538 86.667-59.716 105.397-40.818c18.72 18.898-1.132 64.823-38.992 102.349c-37.86 37.525-86.062 60.925-104.78 42.027c-18.73-18.885.515-66.032 38.375-103.558Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby9)" d="m52.744 253.916l29.408-97.409l97.665 31.376c-35.312 33.113-74.587 61.106-127.073 66.033Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubya)" d="m155.092 88.622l25.073 99.313c29.498-31.016 55.972-64.36 68.938-105.603l-94.01 6.29Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyb)" d="M248.847 82.833c10.035-30.282 12.35-73.725-34.966-81.791l-38.825 21.445l73.791 60.346Z"/><path fill="#9E1209" d="M0 202.935c1.39 49.979 37.448 50.724 52.808 51.162l-35.48-82.86L0 202.935Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubye)" d="M155.232 88.777c22.667 13.932 68.35 41.912 69.276 42.426c1.44.81 19.695-30.784 23.838-48.64l-93.114 6.214Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyf)" d="m82.113 156.507l39.313 75.848c23.246-12.607 41.45-27.967 58.121-44.42l-97.434-31.428Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyc)" d="m17.174 171.34l-5.57 66.328c10.51 14.357 24.97 15.605 40.136 14.486c-10.973-27.311-32.894-81.92-34.566-80.814Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyd)" d="m174.826 22.654l78.1 10.96c-4.169-17.662-16.969-29.06-38.787-32.623l-39.313 21.663Z"/></svg>

}
        href="/quickstarts/ruby"
      >
        Embed a real-time notification center component in your Ruby application.
      </Card>
    </CardGroup>
  </Accordion>

  <Accordion title="Explore our SDKs">
    You can interface with Novu's API either over REST, or via libraries for certain languages. Below is a list of our official, supported libraries.

    ### Client Side

    The Client side libraries and components helps to add a fully functional notification center to your application.

    <CardGroup>
      <Card title="React" icon="react" href="/sdks/react">
        Embed a real-time notification center component in your React application.
      </Card>

      <Card title="Vue" icon="vuejs" href="/sdks/vue">
        Embed a real-time notification center component in your Vue application.
      </Card>

      <Card title="Angular" icon="angular" href="/sdks/angular">
        Embed a real-time notification center component in your Angular application.
      </Card>

      <Card title="Web Component" icon="square-js" href="/sdks/web-component">
        Embed a real-time notification center component in your JavaScript application.
      </Card>

      <Card title="IFrame Embed" icon="frame" href="/sdks/iframe-embed">
        Embed a real-time notification center inside an iframe using our embedded script.
      </Card>

      <Card title="Headless JavaScript" icon="js" href="/sdks/headless-javascript-service">
        Embed a notification system into any framework or vanilla JavaScript project, without being constrained by our default UI or dependencies.
      </Card>
    </CardGroup>

    ### Server Side

    The Server Side libraries help to trigger notifications and interact with all of Novu’s API seamlessly.

    <CardGroup>
      <Card
        title="Node.js"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="21.47" viewBox="0 0 512 314"><defs><linearGradient id="logosNodejs0" x1="68.188%" x2="27.823%" y1="17.487%" y2="89.755%"><stop offset="0%" stopColor="#41873F"/><stop offset="32.88%" stopColor="#418B3D"/><stop offset="63.52%" stopColor="#419637"/><stop offset="93.19%" stopColor="#3FA92D"/><stop offset="100%" stopColor="#3FAE2A"/></linearGradient><linearGradient id="logosNodejs1" x1="43.277%" x2="159.245%" y1="55.169%" y2="-18.306%"><stop offset="13.76%" stopColor="#41873F"/><stop offset="40.32%" stopColor="#54A044"/><stop offset="71.36%" stopColor="#66B848"/><stop offset="90.81%" stopColor="#6CC04A"/></linearGradient><linearGradient id="logosNodejs2" x1="-4413.77%" x2="5327.93%" y1="13.43%" y2="13.43%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs3" x1="-4.389%" x2="101.499%" y1="49.997%" y2="49.997%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs4" x1="-9713.77%" x2="27.93%" y1="36.21%" y2="36.21%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs5" x1="-103.861%" x2="100.797%" y1="50.275%" y2="50.275%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs6" x1="130.613%" x2="4.393%" y1="-211.069%" y2="201.605%"><stop offset="0%" stopColor="#41873F"/><stop offset="32.88%" stopColor="#418B3D"/><stop offset="63.52%" stopColor="#419637"/><stop offset="93.19%" stopColor="#3FA92D"/><stop offset="100%" stopColor="#3FAE2A"/></linearGradient><path id="logosNodejs7" d="M57.903 1.85a5.957 5.957 0 0 0-5.894 0L3.352 29.933c-1.85 1.04-2.89 3.005-2.89 5.085v56.286c0 2.08 1.156 4.045 2.89 5.085l48.657 28.085a5.957 5.957 0 0 0 5.894 0l48.658-28.085c1.849-1.04 2.89-3.005 2.89-5.085V35.019c0-2.08-1.157-4.045-2.89-5.085L57.903 1.85Z"/></defs><g fill="none"><path fill="#539E43" d="M253.11 313.094c-1.733 0-3.351-.462-4.854-1.271l-15.371-9.13c-2.312-1.272-1.156-1.734-.462-1.965c3.12-1.04 3.698-1.272 6.934-3.12c.347-.232.81-.116 1.156.115l11.789 7.05c.462.231 1.04.231 1.386 0l46.115-26.698c.462-.231.694-.694.694-1.271v-53.28c0-.579-.232-1.04-.694-1.272l-46.115-26.582c-.462-.232-1.04-.232-1.386 0l-46.115 26.582c-.462.231-.694.809-.694 1.271v53.28c0 .463.232 1.04.694 1.272l12.598 7.281c6.819 3.467 11.095-.578 11.095-4.623v-52.587c0-.693.578-1.387 1.387-1.387h5.894c.694 0 1.387.578 1.387 1.387v52.587c0 9.13-4.97 14.447-13.638 14.447c-2.658 0-4.738 0-10.633-2.89l-12.135-6.934c-3.005-1.733-4.854-4.97-4.854-8.437v-53.28c0-3.467 1.849-6.704 4.854-8.437l46.114-26.698c2.89-1.618 6.82-1.618 9.709 0l46.114 26.698c3.005 1.733 4.855 4.97 4.855 8.437v53.28c0 3.467-1.85 6.704-4.855 8.437l-46.114 26.698c-1.503.694-3.236 1.04-4.854 1.04Zm14.216-36.637c-20.225 0-24.386-9.246-24.386-17.105c0-.694.578-1.387 1.387-1.387h6.01c.693 0 1.271.462 1.271 1.156c.925 6.125 3.583 9.13 15.834 9.13c9.708 0 13.87-2.196 13.87-7.397c0-3.005-1.157-5.2-16.297-6.703c-12.598-1.272-20.457-4.045-20.457-14.1c0-9.362 7.86-14.91 21.035-14.91c14.793 0 22.075 5.086 23 16.18c0 .348-.116.694-.347 1.041c-.232.231-.578.462-.925.462h-6.01c-.578 0-1.156-.462-1.271-1.04c-1.387-6.356-4.97-8.437-14.447-8.437c-10.633 0-11.905 3.699-11.905 6.472c0 3.352 1.503 4.392 15.834 6.241c14.216 1.85 20.92 4.508 20.92 14.447c-.116 10.171-8.437 15.95-23.116 15.95Z"/><path fill="#333" d="M110.028 104.712c0-2.08-1.156-4.046-3.005-5.086l-49.004-28.2c-.81-.463-1.734-.694-2.658-.81h-.463c-.924 0-1.849.347-2.658.81l-49.004 28.2c-1.85 1.04-3.005 3.005-3.005 5.086l.116 75.817c0 1.04.578 2.08 1.502 2.543c.925.578 2.08.578 2.89 0l29.125-16.643c1.849-1.04 3.005-3.005 3.005-5.085v-35.482c0-2.08 1.155-4.045 3.005-5.085l12.366-7.166c.925-.578 1.965-.81 3.005-.81c1.04 0 2.08.232 2.89.81l12.366 7.166c1.85 1.04 3.005 3.004 3.005 5.085v35.482c0 2.08 1.156 4.045 3.005 5.085l29.125 16.643a2.82 2.82 0 0 0 3.005 0c.925-.463 1.503-1.503 1.503-2.543l-.116-75.817ZM345.571.347c-.924-.463-2.08-.463-2.89 0c-.924.578-1.502 1.502-1.502 2.542v75.125c0 .693-.346 1.386-1.04 1.849c-.693.346-1.387.346-2.08 0l-12.251-7.05a5.957 5.957 0 0 0-5.895 0l-49.004 28.316c-1.849 1.04-3.005 3.005-3.005 5.085v56.516c0 2.08 1.156 4.046 3.005 5.086l49.004 28.316a5.957 5.957 0 0 0 5.895 0l49.004-28.316c1.849-1.04 3.005-3.005 3.005-5.086V21.844c0-2.196-1.156-4.16-3.005-5.201L345.572.347Zm-4.507 143.776c0 .578-.231 1.04-.694 1.271l-16.758 9.708a1.714 1.714 0 0 1-1.503 0l-16.758-9.708c-.463-.231-.694-.809-.694-1.271v-19.417c0-.578.231-1.04.694-1.271l16.758-9.709a1.714 1.714 0 0 1 1.503 0l16.758 9.709c.463.23.694.809.694 1.271v19.417Zm167.584-19.879c1.85-1.04 2.89-3.005 2.89-5.086v-13.753c0-2.08-1.156-4.045-2.89-5.085l-48.657-28.2a5.957 5.957 0 0 0-5.895 0l-49.004 28.315c-1.85 1.04-3.005 3.005-3.005 5.085v56.517c0 2.08 1.156 4.045 3.005 5.085l48.657 27.738c1.85 1.04 4.046 1.04 5.78 0L489 178.45c.925-.463 1.503-1.503 1.503-2.543c0-1.04-.578-2.08-1.503-2.543l-49.235-28.316c-.925-.578-1.503-1.502-1.503-2.542v-17.683c0-1.04.578-2.08 1.503-2.543l15.371-8.784a2.821 2.821 0 0 1 3.005 0l15.372 8.784c.925.578 1.502 1.502 1.502 2.543v13.869c0 1.04.578 2.08 1.503 2.542a2.82 2.82 0 0 0 3.005 0l29.125-16.99Z"/><path fill="#539E43" d="M456.292 121.585a1.05 1.05 0 0 1 1.156 0l9.362 5.432c.346.232.577.578.577 1.04v10.865c0 .462-.23.809-.577 1.04l-9.362 5.432a1.05 1.05 0 0 1-1.156 0l-9.361-5.432c-.347-.231-.578-.578-.578-1.04v-10.864c0-.463.23-.81.578-1.04l9.361-5.433Z"/><g transform="translate(134.068 70.501)"><mask id="logosNodejs8" fill="#fff"><use href="#logosNodejs7"/></mask><use fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs0)" href="#logosNodejs7"/><g mask="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs8)"><path d="M51.893 1.85L3.121 29.933C1.27 30.974 0 32.94 0 35.02v56.286c0 1.387.578 2.658 1.502 3.698L56.285 1.156c-1.387-.231-3.005-.116-4.392.693Zm4.739 123.203c.462-.116.925-.347 1.387-.578l48.773-28.085c1.85-1.04 3.005-3.005 3.005-5.085V35.019c0-1.502-.694-3.005-1.734-4.045l-51.43 94.079Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs1)" d="M106.676 29.934L57.788 1.85a8.025 8.025 0 0 0-1.503-.578L1.502 95.12a6.082 6.082 0 0 0 1.619 1.387l48.888 28.085c1.387.809 3.005 1.04 4.507.577l51.432-94.078c-.347-.462-.81-.81-1.272-1.156Z"/></g><g mask="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs8)"><path d="M109.797 91.305V35.019c0-2.08-1.271-4.045-3.12-5.085L57.786 1.85a5.106 5.106 0 0 0-1.848-.693l53.511 91.42c.231-.347.347-.809.347-1.271ZM3.12 29.934C1.272 30.974 0 32.94 0 35.02v56.286c0 2.08 1.387 4.045 3.12 5.085l48.889 28.085c1.156.693 2.427.925 3.814.693L3.467 29.818l-.346.116Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs2)" fillRule="evenodd" d="m50.391.809l-.693.347h.924l-.231-.347Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs3)" fillRule="evenodd" d="M106.792 105.636c1.387-.809 2.427-2.196 2.89-3.698L56.053 10.402c-1.387-.231-2.89-.116-4.16.693L3.351 39.065l52.355 95.465a8.057 8.057 0 0 0 2.196-.693l48.889-28.2Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs4)" fillRule="evenodd" d="m111.3 104.712l-.347-.578v.809l.346-.231Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs5)" fillRule="evenodd" d="m106.792 105.636l-48.773 28.085a6.973 6.973 0 0 1-2.196.693l.925 1.734l54.089-31.32v-.694l-1.387-2.312c-.231 1.618-1.271 3.005-2.658 3.814Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs6)" fillRule="evenodd" d="m106.792 105.636l-48.773 28.085a6.973 6.973 0 0 1-2.196.693l.925 1.734l54.089-31.32v-.694l-1.387-2.312c-.231 1.618-1.271 3.005-2.658 3.814Z" transform="translate(0 -9.246)"/></g></g></g></svg>
}
        href="/sdks/nodejs"
      >
        Connect your Node app to Novu via the Node.js SDK.
      </Card>

      <Card
        title="Go"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="13.13" viewBox="0 0 512 192"><path fill="#00ACD7" d="m292.533 13.295l1.124.75c13.212 8.725 22.685 20.691 28.917 35.15c1.496 2.243.499 3.49-2.493 4.237l-5.063 1.296c-11.447 2.949-20.53 5.429-31.827 8.378l-6.443 1.678c-2.32.574-2.96.333-5.428-2.477l-.348-.399c-3.519-3.988-6.155-6.652-10.817-9.03l-.899-.443c-15.705-7.727-30.911-5.484-45.12 3.74c-16.952 10.968-25.677 27.172-25.428 47.364c.25 19.942 13.96 36.395 33.654 39.137c16.951 2.244 31.16-3.739 42.378-16.452c2.244-2.743 4.238-5.734 6.73-9.224h-48.11c-5.235 0-6.481-3.24-4.736-7.478l.864-2.035c3.204-7.454 8.173-18.168 11.4-24.294l.704-1.319c.862-1.494 2.612-3.513 5.977-3.513h80.224c3.603-11.415 9.449-22.201 17.246-32.407c18.198-23.931 40.135-36.396 69.8-41.63c25.427-4.488 49.359-1.995 71.046 12.713c19.694 13.461 31.909 31.66 35.15 55.59c4.237 33.654-5.485 61.075-28.668 84.508c-16.453 16.702-36.645 27.172-59.829 31.908c-6.73 1.247-13.461 1.496-19.942 2.244c-22.685-.499-43.376-6.98-60.826-21.937c-12.273-10.61-20.727-23.648-24.928-38.828a104.937 104.937 0 0 1-10.47 16.89c-17.949 23.683-41.381 38.39-71.046 42.38c-24.43 3.24-47.115-1.497-67.058-16.454c-18.447-13.96-28.917-32.407-31.66-55.34c-3.24-27.173 4.737-51.603 21.19-73.041c17.7-23.184 41.132-37.891 69.8-43.126c22.999-4.16 45.037-1.595 64.936 11.464ZM411.12 49.017l-.798.178c-23.183 5.235-38.14 19.942-43.624 43.375c-4.488 19.444 4.985 39.138 22.934 47.115c13.71 5.983 27.421 5.235 40.633-1.496c19.694-10.22 30.413-26.175 31.66-47.613c-.25-3.24-.25-5.734-.749-8.227c-4.436-24.401-26.664-38.324-50.056-33.332ZM116.416 94.564c.997 0 1.496.748 1.496 1.745l-.499 5.983c0 .997-.997 1.745-1.745 1.745l-54.344-.249c-.997 0-1.246-.748-.748-1.496l3.49-6.232c.499-.748 1.496-1.496 2.493-1.496h49.857ZM121.9 71.63c.997 0 1.496.748 1.247 1.496l-1.995 5.983c-.249.997-1.246 1.495-2.243 1.495l-117.912.25c-.997 0-1.246-.499-.748-1.247l5.235-6.73c.499-.748 1.745-1.247 2.742-1.247H121.9Zm12.963-22.934c.997 0 1.246.748.748 1.496l-4.238 6.481c-.499.748-1.745 1.496-2.493 1.496l-90.24-.25c-.998 0-1.247-.498-.749-1.246l5.235-6.73c.499-.748 1.745-1.247 2.742-1.247h88.995Z"/></svg>
}
        href="/sdks/go"
      >
        Connect your Golang app to Novu via the Go SDK.
      </Card>

      <Card
        title="PHP"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#deviconPhp0)" d="M0 64c0 18.593 28.654 33.667 64 33.667c35.346 0 64-15.074 64-33.667c0-18.593-28.655-33.667-64-33.667C28.654 30.333 0 45.407 0 64Z"/><path fill="#777bb3" d="M64 95.167c33.965 0 61.5-13.955 61.5-31.167c0-17.214-27.535-31.167-61.5-31.167S2.5 46.786 2.5 64c0 17.212 27.535 31.167 61.5 31.167Z"/><path d="M34.772 67.864c2.793 0 4.877-.515 6.196-1.53c1.306-1.006 2.207-2.747 2.68-5.175c.44-2.27.272-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.464l-2.473 12.732zM20.173 83.547a.694.694 0 0 1-.68-.828l6.557-33.738a.695.695 0 0 1 .68-.561h14.134c4.442 0 7.748 1.206 9.827 3.585c2.088 2.39 2.734 5.734 1.917 9.935c-.333 1.711-.905 3.3-1.7 4.724a15.818 15.818 0 0 1-3.128 3.92c-1.531 1.432-3.264 2.472-5.147 3.083c-1.852.604-4.232.91-7.07.91h-5.724l-1.634 8.408a.695.695 0 0 1-.682.562z"/><path fill="#fff" d="M34.19 55.826h3.891c3.107 0 4.186.682 4.553 1.089c.607.674.723 2.097.331 4.112c-.439 2.257-1.253 3.858-2.42 4.756c-1.194.92-3.138 1.386-5.773 1.386h-2.786l2.205-11.342zm6.674-8.1H26.731a1.39 1.39 0 0 0-1.364 1.123L18.81 82.588a1.39 1.39 0 0 0 1.363 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.151c2.912 0 5.364-.318 7.287-.944c1.977-.642 3.796-1.731 5.406-3.237a16.522 16.522 0 0 0 3.259-4.087c.831-1.487 1.429-3.147 1.775-4.931c.86-4.423.161-7.964-2.076-10.524c-2.216-2.537-5.698-3.823-10.349-3.823zM30.301 68.557h4.471c2.963 0 5.17-.557 6.62-1.675c1.451-1.116 2.428-2.98 2.938-5.591c.485-2.508.264-4.277-.665-5.308c-.931-1.03-2.791-1.546-5.584-1.546h-5.036l-2.743 14.12m10.563-19.445c4.252 0 7.353 1.117 9.303 3.348c1.95 2.232 2.536 5.347 1.76 9.346c-.322 1.648-.863 3.154-1.625 4.518c-.764 1.366-1.76 2.614-2.991 3.747c-1.468 1.373-3.097 2.352-4.892 2.935c-1.794.584-4.08.875-6.857.875h-6.296l-1.743 8.97h-7.35l6.558-33.739h14.133"/><path d="M69.459 74.577a.694.694 0 0 1-.682-.827l2.9-14.928c.277-1.42.209-2.438-.19-2.87c-.245-.263-.979-.704-3.15-.704h-5.256l-3.646 18.768a.695.695 0 0 1-.683.56h-7.29a.695.695 0 0 1-.683-.826l6.558-33.739a.695.695 0 0 1 .682-.561h7.29a.695.695 0 0 1 .683.826L64.41 48.42h5.653c4.307 0 7.227.758 8.928 2.321c1.733 1.593 2.275 4.14 1.608 7.573l-3.051 15.702a.695.695 0 0 1-.682.56h-7.407z"/><path fill="#fff" d="M65.31 38.755h-7.291a1.39 1.39 0 0 0-1.364 1.124l-6.557 33.738a1.39 1.39 0 0 0 1.363 1.654h7.291a1.39 1.39 0 0 0 1.364-1.124l3.537-18.205h4.682c2.168 0 2.624.463 2.641.484c.132.14.305.795.019 2.264l-2.9 14.927a1.39 1.39 0 0 0 1.364 1.654h7.408a1.39 1.39 0 0 0 1.363-1.124l3.051-15.7c.715-3.686.103-6.45-1.82-8.217c-1.836-1.686-4.91-2.505-9.398-2.505h-4.81l1.421-7.315a1.39 1.39 0 0 0-1.364-1.655zm0 1.39l-1.743 8.968h6.496c4.087 0 6.907.714 8.457 2.14c1.553 1.426 2.017 3.735 1.398 6.93l-3.052 15.699h-7.407l2.901-14.928c.33-1.698.208-2.856-.365-3.474c-.573-.617-1.793-.926-3.658-.926h-5.829l-3.756 19.327H51.46l6.558-33.739h7.292z"/><path d="M92.136 67.864c2.793 0 4.878-.515 6.198-1.53c1.304-1.006 2.206-2.747 2.679-5.175c.44-2.27.273-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.463l-2.475 12.732zM77.54 83.547a.694.694 0 0 1-.682-.828l6.557-33.738a.695.695 0 0 1 .682-.561H98.23c4.442 0 7.748 1.206 9.826 3.585c2.089 2.39 2.734 5.734 1.917 9.935a15.878 15.878 0 0 1-1.699 4.724a15.838 15.838 0 0 1-3.128 3.92c-1.53 1.432-3.265 2.472-5.147 3.083c-1.852.604-4.232.91-7.071.91h-5.723l-1.633 8.408a.695.695 0 0 1-.683.562z"/><path fill="#fff" d="M91.555 55.826h3.891c3.107 0 4.186.682 4.552 1.089c.61.674.724 2.097.333 4.112c-.44 2.257-1.254 3.858-2.421 4.756c-1.195.92-3.139 1.386-5.773 1.386h-2.786l2.204-11.342zm6.674-8.1H84.096a1.39 1.39 0 0 0-1.363 1.123l-6.558 33.739a1.39 1.39 0 0 0 1.364 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.15c2.911 0 5.364-.318 7.286-.944c1.978-.642 3.797-1.731 5.408-3.238a16.52 16.52 0 0 0 3.258-4.086c.832-1.487 1.428-3.147 1.775-4.931c.86-4.423.162-7.964-2.076-10.524c-2.216-2.537-5.697-3.823-10.35-3.823zM87.666 68.557h4.47c2.964 0 5.17-.557 6.622-1.675c1.45-1.116 2.428-2.98 2.936-5.591c.487-2.508.266-4.277-.665-5.308c-.93-1.03-2.791-1.546-5.583-1.546h-5.035Zm10.563-19.445c4.251 0 7.354 1.117 9.303 3.348c1.95 2.232 2.537 5.347 1.759 9.346c-.32 1.648-.862 3.154-1.624 4.518c-.763 1.366-1.76 2.614-2.992 3.747c-1.467 1.373-3.097 2.352-4.892 2.935c-1.793.584-4.078.875-6.856.875h-6.295l-1.745 8.97h-7.35l6.558-33.739h14.133"/><defs><radialGradient id="deviconPhp0" cx="0" cy="0" r="1" gradientTransform="translate(38.426 42.169) scale(84.04136)" gradientUnits="userSpaceOnUse"><stop stopColor="#AEB2D5"/><stop offset=".3" stopColor="#AEB2D5"/><stop offset=".75" stopColor="#484C89"/><stop offset="1" stopColor="#484C89"/></radialGradient></defs></svg>
}
        href="/sdks/php"
      >
        Connect your PHP app to Novu via the PHP SDK.
      </Card>

      <Card title="Laravel" icon="laravel" href="/sdks/laravel">
        Connect your Laravel app to Novu via the Laravel SDK.
      </Card>

      <Card
        title=".NET"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 256 256"><g fill="none"><rect width="256" height="256" fill="#512BD4" rx="60"/><path fill="#fff" d="M24.052 168.943c-2.236 0-4.138-.731-5.703-2.194c-1.566-1.501-2.349-3.283-2.349-5.347c0-2.101.783-3.902 2.349-5.403c1.565-1.5 3.466-2.251 5.703-2.251c2.274 0 4.194.751 5.76 2.251c1.603 1.501 2.404 3.302 2.404 5.403c0 2.064-.801 3.846-2.404 5.347c-1.566 1.463-3.486 2.194-5.76 2.194Zm89.415-1.238H98.929l-38.304-59.318a26.371 26.371 0 0 1-2.404-4.672h-.336c.298 1.726.447 5.422.447 11.087v52.903H45.471V87H60.96l37.018 57.912c1.566 2.402 2.572 4.052 3.02 4.953h.223c-.372-2.139-.559-5.759-.559-10.863V87h12.805v80.705Zm62.631 0h-45.014V87h43.225v11.369h-29.916v22.849h27.568v11.312h-27.568v23.863h31.705v11.312Zm63.973-69.336h-23.038v69.336h-13.309V98.369h-22.982V87h59.329v11.369Z"/></g></svg>
}
        href="/sdks/dotnet"
      >
        Connect your C#/.NET app to Novu via the .NET SDK.
      </Card>

      <Card
        title="Ruby"
        icon={
       <svg xmlns="http://www.w3.org/2000/svg" width="20" height="19.93" viewBox="0 0 256 255"><defs><linearGradient id="logosRuby0" x1="84.75%" x2="58.254%" y1="111.399%" y2="64.584%"><stop offset="0%" stopColor="#FB7655"/><stop offset="0%" stopColor="#FB7655"/><stop offset="41%" stopColor="#E42B1E"/><stop offset="99%" stopColor="#900"/><stop offset="100%" stopColor="#900"/></linearGradient><linearGradient id="logosRuby1" x1="116.651%" x2="1.746%" y1="60.89%" y2="19.288%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby2" x1="75.774%" x2="38.978%" y1="219.327%" y2="7.829%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby3" x1="50.012%" x2="66.483%" y1="7.234%" y2="79.135%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E57252"/><stop offset="46%" stopColor="#DE3B20"/><stop offset="99%" stopColor="#A60003"/><stop offset="100%" stopColor="#A60003"/></linearGradient><linearGradient id="logosRuby4" x1="46.174%" x2="49.932%" y1="16.348%" y2="83.047%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E4714E"/><stop offset="56%" stopColor="#BE1A0D"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby5" x1="36.965%" x2="49.528%" y1="15.594%" y2="92.478%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="18%" stopColor="#E46342"/><stop offset="40%" stopColor="#C82410"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby6" x1="13.609%" x2="85.764%" y1="58.346%" y2="-46.717%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="54%" stopColor="#C81F11"/><stop offset="99%" stopColor="#BF0905"/><stop offset="100%" stopColor="#BF0905"/></linearGradient><linearGradient id="logosRuby7" x1="27.624%" x2="50.745%" y1="21.135%" y2="79.056%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="31%" stopColor="#DE4024"/><stop offset="99%" stopColor="#BF190B"/><stop offset="100%" stopColor="#BF190B"/></linearGradient><linearGradient id="logosRuby8" x1="-20.667%" x2="104.242%" y1="122.282%" y2="-6.342%"><stop offset="0%" stopColor="#BD0012"/><stop offset="0%" stopColor="#BD0012"/><stop offset="7%" stopColor="#FFF"/><stop offset="17%" stopColor="#FFF"/><stop offset="27%" stopColor="#C82F1C"/><stop offset="33%" stopColor="#820C01"/><stop offset="46%" stopColor="#A31601"/><stop offset="72%" stopColor="#B31301"/><stop offset="99%" stopColor="#E82609"/><stop offset="100%" stopColor="#E82609"/></linearGradient><linearGradient id="logosRuby9" x1="58.792%" x2="11.964%" y1="65.205%" y2="50.128%"><stop offset="0%" stopColor="#8C0C01"/><stop offset="0%" stopColor="#8C0C01"/><stop offset="54%" stopColor="#990C00"/><stop offset="99%" stopColor="#A80D0E"/><stop offset="100%" stopColor="#A80D0E"/></linearGradient><linearGradient id="logosRubya" x1="79.319%" x2="23.088%" y1="62.754%" y2="17.888%"><stop offset="0%" stopColor="#7E110B"/><stop offset="0%" stopColor="#7E110B"/><stop offset="99%" stopColor="#9E0C00"/><stop offset="100%" stopColor="#9E0C00"/></linearGradient><linearGradient id="logosRubyb" x1="92.88%" x2="59.841%" y1="74.122%" y2="39.704%"><stop offset="0%" stopColor="#79130D"/><stop offset="0%" stopColor="#79130D"/><stop offset="99%" stopColor="#9E120B"/><stop offset="100%" stopColor="#9E120B"/></linearGradient><linearGradient id="logosRubyc" x1="56.57%" x2="3.105%" y1="101.717%" y2="11.993%"><stop offset="0%" stopColor="#8B2114"/><stop offset="0%" stopColor="#8B2114"/><stop offset="43%" stopColor="#9E100A"/><stop offset="99%" stopColor="#B3100C"/><stop offset="100%" stopColor="#B3100C"/></linearGradient><linearGradient id="logosRubyd" x1="30.87%" x2="92.471%" y1="35.599%" y2="100.694%"><stop offset="0%" stopColor="#B31000"/><stop offset="0%" stopColor="#B31000"/><stop offset="44%" stopColor="#910F08"/><stop offset="99%" stopColor="#791C12"/><stop offset="100%" stopColor="#791C12"/></linearGradient><radialGradient id="logosRubye" cx="32.001%" cy="40.21%" r="69.573%" fx="32.001%" fy="40.21%"><stop offset="0%" stopColor="#A80D00"/><stop offset="0%" stopColor="#A80D00"/><stop offset="99%" stopColor="#7E0E08"/><stop offset="100%" stopColor="#7E0E08"/></radialGradient><radialGradient id="logosRubyf" cx="13.549%" cy="40.86%" r="88.386%" fx="13.549%" fy="40.86%"><stop offset="0%" stopColor="#A30C00"/><stop offset="0%" stopColor="#A30C00"/><stop offset="99%" stopColor="#800E08"/><stop offset="100%" stopColor="#800E08"/></radialGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby0)" d="m197.467 167.764l-145.52 86.41l188.422-12.787L254.88 51.393l-57.414 116.37Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby1)" d="M240.677 241.257L224.482 129.48l-44.113 58.25l60.308 53.528Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby2)" d="m240.896 241.257l-118.646-9.313l-69.674 21.986l188.32-12.673Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby3)" d="m52.744 253.955l29.64-97.1L17.16 170.8l35.583 83.154Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby4)" d="M180.358 188.05L153.085 81.226l-78.047 73.16l105.32 33.666Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby5)" d="m248.693 82.73l-73.777-60.256l-20.544 66.418l94.321-6.162Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby6)" d="M214.191.99L170.8 24.97L143.424.669l70.767.322Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby7)" d="m0 203.372l18.177-33.151l-14.704-39.494L0 203.372Z"/><path fill="#FFF" d="m2.496 129.48l14.794 41.963l64.283-14.422l73.39-68.207l20.712-65.787L143.063 0L87.618 20.75c-17.469 16.248-51.366 48.396-52.588 49c-1.21.618-22.384 40.639-32.534 59.73Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby8)" d="M54.442 54.094c37.86-37.538 86.667-59.716 105.397-40.818c18.72 18.898-1.132 64.823-38.992 102.349c-37.86 37.525-86.062 60.925-104.78 42.027c-18.73-18.885.515-66.032 38.375-103.558Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby9)" d="m52.744 253.916l29.408-97.409l97.665 31.376c-35.312 33.113-74.587 61.106-127.073 66.033Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubya)" d="m155.092 88.622l25.073 99.313c29.498-31.016 55.972-64.36 68.938-105.603l-94.01 6.29Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyb)" d="M248.847 82.833c10.035-30.282 12.35-73.725-34.966-81.791l-38.825 21.445l73.791 60.346Z"/><path fill="#9E1209" d="M0 202.935c1.39 49.979 37.448 50.724 52.808 51.162l-35.48-82.86L0 202.935Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubye)" d="M155.232 88.777c22.667 13.932 68.35 41.912 69.276 42.426c1.44.81 19.695-30.784 23.838-48.64l-93.114 6.214Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyf)" d="m82.113 156.507l39.313 75.848c23.246-12.607 41.45-27.967 58.121-44.42l-97.434-31.428Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyc)" d="m17.174 171.34l-5.57 66.328c10.51 14.357 24.97 15.605 40.136 14.486c-10.973-27.311-32.894-81.92-34.566-80.814Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyd)" d="m174.826 22.654l78.1 10.96c-4.169-17.662-16.969-29.06-38.787-32.623l-39.313 21.663Z"/></svg>

}
        href="/sdks/ruby"
      >
        Connect your Ruby app to Novu via the Ruby SDK.
      </Card>

      <Card
        title="Java"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="#0074BD" d="M47.617 98.12s-4.767 2.774 3.397 3.71c9.892 1.13 14.947.968 25.845-1.092c0 0 2.871 1.795 6.873 3.351c-24.439 10.47-55.308-.607-36.115-5.969zm-2.988-13.665s-5.348 3.959 2.823 4.805c10.567 1.091 18.91 1.18 33.354-1.6c0 0 1.993 2.025 5.132 3.131c-29.542 8.64-62.446.68-41.309-6.336z"/><path fill="#EA2D2E" d="M69.802 61.271c6.025 6.935-1.58 13.17-1.58 13.17s15.289-7.891 8.269-17.777c-6.559-9.215-11.587-13.792 15.635-29.58c0 .001-42.731 10.67-22.324 34.187z"/><path fill="#0074BD" d="M102.123 108.229s3.529 2.91-3.888 5.159c-14.102 4.272-58.706 5.56-71.094.171c-4.451-1.938 3.899-4.625 6.526-5.192c2.739-.593 4.303-.485 4.303-.485c-4.953-3.487-32.013 6.85-13.743 9.815c49.821 8.076 90.817-3.637 77.896-9.468zM49.912 70.294s-22.686 5.389-8.033 7.348c6.188.828 18.518.638 30.011-.326c9.39-.789 18.813-2.474 18.813-2.474s-3.308 1.419-5.704 3.053c-23.042 6.061-67.544 3.238-54.731-2.958c10.832-5.239 19.644-4.643 19.644-4.643zm40.697 22.747c23.421-12.167 12.591-23.86 5.032-22.285c-1.848.385-2.677.72-2.677.72s.688-1.079 2-1.543c14.953-5.255 26.451 15.503-4.823 23.725c0-.002.359-.327.468-.617z"/><path fill="#EA2D2E" d="M76.491 1.587S89.459 14.563 64.188 34.51c-20.266 16.006-4.621 25.13-.007 35.559c-11.831-10.673-20.509-20.07-14.688-28.815C58.041 28.42 81.722 22.195 76.491 1.587z"/><path fill="#0074BD" d="M52.214 126.021c22.476 1.437 57-.8 57.817-11.436c0 0-1.571 4.032-18.577 7.231c-19.186 3.612-42.854 3.191-56.887.874c0 .001 2.875 2.381 17.647 3.331z"/></svg>
}
        href="/sdks/java"
      >
        Connect your Java app to Novu via the Java SDK.
      </Card>

      <Card
        title="Kotlin"
        icon={
  <svg
    xmlns="http://www.w3.org/2000/svg"
    width="20"
    height="20"
    viewBox="0 0 256 256"
  >
    <defs>
      <linearGradient
        id="logosKotlinIcon0"
        x1="99.991%"
        x2=".01%"
        y1="-.011%"
        y2="100.01%"
      >
        <stop offset=".344%" stopColor="#E44857" />
        <stop offset="46.89%" stopColor="#C711E1" />
        <stop offset="100%" stopColor="#7F52FF" />
      </linearGradient>
    </defs>
    <path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosKotlinIcon0)" d="M256 256H0V0h256L128 127.949z" />
  </svg>
}
        href="/sdks/kotlin"
      >
        Connect your Kotlin app to Novu via the Kotlin SDK.
      </Card>

      <Card
        title="Python"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="34.87" viewBox="0 0 256 255"><defs><linearGradient id="logosPython0" x1="12.959%" x2="79.639%" y1="12.039%" y2="78.201%"><stop offset="0%" stopColor="#387EB8"/><stop offset="100%" stopColor="#366994"/></linearGradient><linearGradient id="logosPython1" x1="19.128%" x2="90.742%" y1="20.579%" y2="88.429%"><stop offset="0%" stopColor="#FFE052"/><stop offset="100%" stopColor="#FFC331"/></linearGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosPython0)" d="M126.916.072c-64.832 0-60.784 28.115-60.784 28.115l.072 29.128h61.868v8.745H41.631S.145 61.355.145 126.77c0 65.417 36.21 63.097 36.21 63.097h21.61v-30.356s-1.165-36.21 35.632-36.21h61.362s34.475.557 34.475-33.319V33.97S194.67.072 126.916.072ZM92.802 19.66a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.13Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosPython1)" d="M128.757 254.126c64.832 0 60.784-28.115 60.784-28.115l-.072-29.127H127.6v-8.745h86.441s41.486 4.705 41.486-60.712c0-65.416-36.21-63.096-36.21-63.096h-21.61v30.355s1.165 36.21-35.632 36.21h-61.362s-34.475-.557-34.475 33.32v56.013s-5.235 33.897 62.518 33.897Zm34.114-19.586a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.131a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13Z"/></svg>
}
        href="/sdks/python"
      >
        Connect your Python app to Novu via the Python SDK.
      </Card>
    </CardGroup>
  </Accordion>
</AccordionGroup>

The [Novu Cloud SaaS](https://web.novu.co) platform provides an intuitive internal user interface, embeddable UI end-user components, and a hybrid code-first workflow capability.

Novu eliminates the significant burden of building, hosting, and managing a notifications infrastructure that all modern software businesses need in order to notify and engage staff, end users, and customers.

## Notification types

Novu supports different notification types, including user-generated and machine-generated notifications.

### Machine generated

* Triggered by some automated action—think a container pod scaling event.
* Notify one or more end users (which can be internal users, of course!).
* Often can be voluminous, so digests are helpful.

### Product notifications

* Triggered by end-user interactions and events within your product.
* Notify one or more subscribers.
* Typically transactional, such as order updates, password resets, account verifications, or login/OTP codes.
* Can also be used to provide product updates, such as new features or bug fixes.

### Promotional notifications

* Centered on promoting products, services, or events.
* Can be used to generate leads, increase sales, or drive engagement.

### Key Differences

* Product notifications are triggered by user activity, while promotional notifications are sent at the discretion of the marketer.
* Product notifications are typically more transactional in nature, while promotional notifications are more marketing-oriented.
* Product notifications are often sent to all subscribers, while promotional notifications can be targeted to specific audiences.

## Notification channels

Novu supports all major notification channels, and integrates with multiple delivery providers for each one. Each channel can use the same source notification content, as desired.

* [Email](/channels-and-providers/email/overview)
* [Push](/channels-and-providers/push/overview)
* [SMS](/channels-and-providers/sms/overview)
* [Chat](/channels-and-providers/chat/overview)
* [In-App](/channels-and-providers/in-app/introduction)

## Who is Novu for?

How you use and get started with Novu depends on your role. While it’s implemented initially by engineering and development teams, Novu unifies everyone in an organization that authors, creates, sends, manages and measures results from notifications being sent to end users. Novu empowers engineers to deliver notification platforms for product teams.

### Novu for developers and engineering teams

Novu empowers developers and engineering teams to quickly deliver a fully extensible notifications platform for product teams to create captivating notification experiences.

We provide the following proven stack for developers to simply integrate into their products:

* **[Unified API](/api-reference/overview)  & [SDK clients](/sdks/introduction)** for managing all channels and platforms across multiple programming languages.
* **[Prebuilt, customisable UI components](/notification-center/introduction#ui-libraries)** for in-app user notification feeds and preference experiences.
* **[Integration with multiple delivery providers](/channels-and-providers/introduction)**, allowing you to continue using your preferred vendors with Novu.
* **[Scalable, reliable Novu Cloud SaaS infrastructure](https://web.novu.co)** developed from scratch to meet the demands of high-volume notification delivery and storage (think hundreds of millions of notifications).
* **[Observability](/activity-feed/introduction)** for delving into the lifecycle of notification’s success or failure.  Eliminate guesswork of how, when, and why a user receives a notification.
* **Comprehensive documentation**, implementation guides, recipes and illustrative examples.
* **Compliance and security** for safely managing your data.
* **Open source** based provides trust, generates significant community input, and enables you to deploy and self-host a Novu Project instance into any environment of your choosing.

Notification content can be written in a variety of common content tooling, including [React](/framework/integrations/react-email), [Vue-email](/framework/integrations/vue-email), [MJML](/guides/framework-guides/framework-mjml), and more. Content can also be customized and hydrated using any datasource.

### Novu for product teams

We are well aware of the friction that often exists between engineering and product teams, and have built features that allow product teams to customize notification experiences easily and safely—without risking disrupting or breaking important integrations and logic.

Product teams can craft beautiful notification content and campaigns in any content framework of their choice.

* They can modify and manage notification UIs that engineers have built via Novu workflows.
* They gain valuable insights into user engagement with notifications via logs and analytics.
* They can use their preferred notification content editors.
* They can focus on crafting impactful notification content while engineers

### Novu for end users

When implemented, most end users will not be aware that it’s Novu behind the scenes, other than that they now receive notifications where and when they expect them.

The [Novu Notification Center](/notification-center/introduction) is an embeddable component that when included in your app, enables users to view and set their own notification preferences, including channel, preferred language, and more.

Novu ensures fast delivery and beautiful notification experiences for end users regardless of the channels involved.

With Novu, your app users receive instant notifications via **email**, **in-app alerts**, **SMS**, **push notifications**, and **chat**.

## Use Cases

Novu is heavily customizable, and can tackle nearly any notification requirement, no matter how simple or complex. These are some of the more common use cases:

* **Manage multiple notification providers:** Novu empowers you to manage all your notification delivery providers across email, SMS, push and chat in one place. Developers can add new notification providers across different channels without changing the app codebase.
* **Centralize legacy notification systems:** Reduce notification complexity, unify management and visibility into one platform.
* **Centralized debugging of notifications across multiple channels**: Novu allows you understand and debug notifications sent across different channels in one place.
* **In-app Notification Center:** Novu provides a real-time embedded notification center widget that can simply be dropped into any web application to enable end users to manage their own notification preferences.
* **Notification personalization:** Novu provides a user preferences feature that gives your end users a say in how they want to receive notifications.
* **Notification content management:** Novu provides the ability to integrate any content framework and tool of your choice to manage notification content across teams.
* **Send notifications in users language of choice**: Novu allows you to send notifications in preferred users language. App and notification internalization increases users engagement and retention in your product.
* **Reduce notification alert fatigue**: Novu prevents notification fatigue by providing the ability to batch multiple notifications and send as one to subscribers (end users). Leverage Novu in digesting multiple notification events.


# Sign Up on Novu Cloud
Source: https://v0.x-docs.novu.co/getting-started/novu-sign-up

Sign up to our managed service

## Introduction

Novu’s aim is to simplify sending notifications across platforms. As such, we provide simple components, APIs, SDKs and more to help you manage product communication across channels.

This comprehensive guide will help you kickstart your journey with Novu and get your hands dirty!

Everything you need to get up and running successfully can be found here. Let’s begin!

## Signing up to Novu Cloud

Novu Cloud is our managed service that lets you oversee all aspects of your product communication from a user-friendly web dashboard. With Novu Cloud, you can handle various communication channels, create and manage workflows, switch organizations and monitor your activity, ensuring that you get comprehensive control over your product communication and that your message reaches your customers effectively.

To be able to do this and a lot more, you need to sign up for Novu Cloud:

1. Head to [Novu Cloud](https://web.novu.co/auth/signup?utm_campaign=docs-gs-signup). You’ll see this:

<Frame>
  <img />
</Frame>

2. To sign up, you can either use your email and password or sign up using Github. Choose what you wish to proceed with, read the terms and conditions, check its checkbox and click the sign-up button.

<Frame>
  <img />
</Frame>

3. You’ll then be asked to create an Organization. Organizations help you segregate communication between your different products. You can learn more about organisations here. Simply enter your organization name and click on the ‘create’ button:

<Frame>
  <img />
</Frame>

4. On creating an organization, you’ll be greeted with the get started page:

<Frame>
  <img />
</Frame>

This gives you access to a lot of options:

<Frame>
  <img />
</Frame>

1. Accessing support
2. Managing your account
3. Configuring different channels
4. Navigating to any other sections of the dashboard

From here, you can navigate to any part of the web dashboard. Let’s now see Novu in action!


# Send Your First Notification
Source: https://v0.x-docs.novu.co/getting-started/send-your-first-notification

Learn how to send your first notification via the Novu Cloud dashboard.

Sending the first notification is fairly simple, and can be done from within the web dashboard. To send your first notification, follow these steps:

## Workflow for Email notifications

1. Navigate to the workflow section from the left sidebar:

   <Frame>
     <img />
   </Frame>

2. Click on the `Blank Workflow` button to create an empty workflow:

   <Frame>
     <img />
   </Frame>

3. You are now in the workflow editor. Here you can add steps to your workflow. We’ll just drag the email node from the right sidebar to our workflow as illustrated below:

   <Frame>
     <img />
   </Frame>

4. Now, simply click on the email node, and add the subject and the notification
   text in the email node editor:

   <Frame>
     <img />
   </Frame>

5. Now, update the workflow and save it as shown in the image below:

   <Frame>
     <img />
   </Frame>

6. Now, to execute this workflow, click on the `get snippet` button from the workflow editor:

   <Frame>
     <img />
   </Frame>

7. From the `run a test` tab, you can change the email to which you want the notification. Once you’ve done that, simply click on the `Run Trigger` button on the bottom right:

   <Frame>
     <img />
   </Frame>

8. Now, go to the inbox and you’ll see the email notification there. Don’t forget also to check spam as it may sometimes land in there:

   <Frame>
     <img />
   </Frame>

9. This gif below captures the entire process:

   <Frame>
     <img />
   </Frame>

## Workflow for In-App notifications

Creating workflows for sending in-app notifications is pretty straightforward. Just follow the following steps and you'll be good to go:

1. Head to `workflows` on the [Novu web dashboard](https://web.novu.co/workflows?utm_campaign=docs-gs-sendfirstnotification).

   <Frame>
     <img />
   </Frame>

2. Click on the Blank Workflow button to create a workflow from scratch.

   <Frame>
     <img />
   </Frame>

<Note>
  If you want to avoid creating a workflow from scratch, then instead of
  choosing `Blank Workflow`, select `All Templates` and you'll find a bunch of
  workflow templates that you can customize and use:

  <Frame>
    <img />
  </Frame>

  <br />

  <Frame>
    <img />
  </Frame>
</Note>

3. You'll now end up in the workflow editor. Workflow editor, as the name suggests, is the place from where you can edit workflows. You can select which [channels](/channels-and-providers/introduction#channels) you want to send notifications in, add [digest](/guides/add-digest-to-inapp-notifications) to your in-app notifications and more.

   <Frame>
     <img />
   </Frame>

4. For your use case here, we'll simply add an `in-app` node to our workflow.

   <Note>
     Don't forget to rename your workflow to an appropriate name.

     <Frame>
       <img />
     </Frame>
   </Note>

5. Now, the `in-app` node has a lot of options for you to configure:

   <Frame>
     <img />
   </Frame>

* **Preview**: This shows you a glimpse of what each notification item will look like in the Notification Center UI.
* **Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.

6. In this editor, you need to plug in the variable that your backend is expecting in the payload:

   <Frame>
     <img />
   </Frame>

7. You can even use [handlebars](/content-creation-design/handlebars-helpers) to further customise this.

8. Once you're done configuring it, simply click the `update` button on the top right corner.

   <Frame>
     <img />
   </Frame>

9. Now, simply click on the `Get Snippet` button to get the trigger code snippet.

   <Frame>
     <img />
   </Frame>

10. You'll get the code that you need to plug into your backend to be executed whenever an event fires.

    <Frame>
      <img />
    </Frame>

    <br />

    <Warning>
      Don't forget to use your actual `API_KEY` and `subscriberId`.
    </Warning>

That's it, you've successfully built a workflow for sending in-app notifications!

## Workflow for SMS notifications

SMS workflows are not very different from [email](/getting-started/send-your-first-notification#workflow-for-email-notifications) and [in-app](localhost:3001/getting-started/send-your-first-notification#workflow-for-in-app-notifications) workflows we've created above. Let's take a look at it:

1. Head to `Workflows` on the [Novu web dashboard.](https://web.novu.co/workflows?utm_campaign=docs-gs-sendfirstnotification)

   <Frame>
     <img />
   </Frame>

2. Click on the `Blank Workflow` button to create a workflow from scratch.

   <Frame>
     <img />
   </Frame>

<Note>
  If you want to avoid creating a workflow from scratch, then instead of
  choosing `Blank Workflow`, select `All Templates` and you'll find a bunch of
  workflow templates that you can customize and use:

  <Frame>
    <img />
  </Frame>

  <br />

  <Frame>
    <img />
  </Frame>
</Note>

3. You'll now end up in the workflow editor. Workflow editor, as the name suggests, is the place from where you can edit workflows. You can select which [channels](/channels-and-providers/introduction#channels) you want to send notifications in, add [digest](/guides/add-digest-to-inapp-notifications) to your in-app notifications and more.

   <Frame>
     <img />
   </Frame>

4. Since we're creating a workflow for SMS notifications, we'll drag the `SMS` step to our workflow, as shown in this picture below:

   <Frame>
     <img />
   </Frame>

5. If you hover over the SMS node, you will get a message saying 'Required - SMS content\`. Click on the SMS node and add a message to it. This is what will be sent as a notification in the SMS.

   <Frame>
     <img />
   </Frame>

   <br />

   <Note>
     Instead of having static messages, you can have your notifications be
     dynamic by using `handlebars`. Take a look
     [here](/content-creation-design/handlebars-helpers) for more. If your
     backend is expecting data in the payload, plug that variable here in double
     braces.
   </Note>

6. Once you’re done configuring it, simply click the update button on the top right corner.

   <Frame>
     <img />
   </Frame>

7. Now, simply click on the Get Snippet button to get the trigger code snippet.

   <Frame>
     <img />
   </Frame>

8. You’ll get the code that you need to plug into your backend to be executed whenever an event fires.

   <Frame>
     <img />
   </Frame>

   <Warning>Don’t forget to use your actual API\_KEY and subscriberId.</Warning>
   That’s it, you’ve successfully built a workflow for sending in-app
   notifications!

## Workflow for Chat notifications

Chat workflows are quite similar to [email](/getting-started/send-your-first-notification#workflow-for-email-notifications), [in-app](localhost:3001/getting-started/send-your-first-notification#workflow-for-in-app-notifications), and [SMS workflows](/getting-started/send-your-first-notification#workflow-for-sms-notifications) workflows we've created above. Let's take a look at it in detail:

1. Head to `Workflows` on the [Novu web dashboard.](https://web.novu.co/workflows?utm_campaign=docs-gs-sendfirstnotification)

   <Frame>
     <img />
   </Frame>

2. Click on the `Blank Workflow` button to create a workflow from scratch.

   <Frame>
     <img />
   </Frame>

   <br />

   <Note>
     If you want to avoid creating a workflow from scratch, then instead of
     choosing `Blank Workflow`, select `All Templates` and you'll find a bunch
     of workflow templates that you can customize and use:

     <Frame>
       <img />
     </Frame>

     <br />

     <Frame>
       <img />
     </Frame>
   </Note>

3. You'll now end up in the workflow editor. Workflow editor, as the name suggests, is the place from where you can edit workflows. You can select which [channels](/channels-and-providers/introduction#channels) you want to send notifications in, add [digest](/guides/add-digest-to-inapp-notifications) to your in-app notifications and more.

   <Frame>
     <img />
   </Frame>

4. Just add this `Chat` node to the workflow.

   <Frame>
     <img />
   </Frame>

5. In the `Chat` node, you can enter the notification message. This is what will get sent to the [subscriber](/subscribers/subscribers) as a notification. If you're sending dynamic messages, use the variable that is expected in your payload in double braces here. Using [handlebars](/content-creation-design/handlebars-helpers), you can further extend this functionality.

   <Frame>
     <img />
   </Frame>

6. Once you’re done configuring it, simply click the update button on the top right corner.

   <Frame>
     <img />
   </Frame>

7. Now, simply click on the Get Snippet button to get the trigger code snippet.

   <Frame>
     <img />
   </Frame>

8. You’ll get the code that you need to plug into your backend to be executed whenever an event fires.

   <Frame>
     <img />
   </Frame>

   <Warning>Don’t forget to use your actual API\_KEY and subscriberId.</Warning>
   That’s it, you’ve successfully built a workflow for sending chat notifications!

Don't forget to check out our [guides](/guides/add-digest-to-inapp-notifications) and [demo apps](/demos/introduction) for more information on specific features.


# Backend SDK methods
Source: https://v0.x-docs.novu.co/notification-center/backend/methods



### Fetch subscriber’s In-App notifications feed

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: inAppMessages } = await novu.subscribers.getNotificationsFeed(
    "subscriberId",
    {
      page: 0,
      limit: 10,

      // it is of type string. By default all feeds messages are fetched
      feedIdentifier: "Product Updates",

      // seen and read filter of type boolean
      seen: true,
      read: true,
    }
  );
  ```
</CodeGroup>

### Fetch all Messages Sent To All Subscribers

<CodeGroup>
  ```javascript Node.JS theme={null}
  import { ChannelTypeEnum } from "@novu/node";

  // All fields are optional
  const listMessagesOptions = {
    // pagination options
    page: 0,
    limit: 20,

    /**
     *  Filter options
     */
    // use ChannelTypeEnum.PUSH for push, ChannelTypeEnum.EMAIL for email,
    channel: ChannelTypeEnum.IN_APP, // only In-App type messages will be fetched
    subscriberId: "6444105141ffb0919496dfcb",
    transactionIds: ["644-41051-41ffb0-919496-dfcb"],
  };

  const { data: messagesData } = await novu.messages.list(listMessagesOptions);
  ```
</CodeGroup>

### Delete an In-App notification/message

<CodeGroup>
  ```javascript Node.JS theme={null}
  // messageId is of MongoDB Id type
  await novu.messages.deleteById("messageId");
  ```
</CodeGroup>

### Mark an In-App Message as Read/Seen

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: markMessageAsRead } = await novu.subscribers.markMessageRead(
    "subscriberId",
    "messageId"
  );

  const { data: markMessageAsSeen } = await novu.subscribers.markMessageSeen(
    "subscriberId",
    "messageId"
  );
  ```
</CodeGroup>

### Mark an In-App Message as Read/Unread/Seen/Unseen

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: markMessageAs } = await novu.subscribers.markMessageAs(
    "subscriberId",
    "messageId",
    { seen: true, read: false }
  );
  ```
</CodeGroup>

### Mark all In-App Messages as Read/Unread/Seen/Unseen

<CodeGroup>
  ```javascript Node.JS theme={null}
  import { MarkMessagesAsEnum } from "@novu/node"

  const { data: markAllInAppMessages } = await novu.subscribers.markAllMessagesAs(
     'subscriberId',

     // can be filtered with feed identifiers
     feedIdentifier: ['Marketing', 'Product']

     // MarkMessageAsEnum.READ => It will mark all messages as read
     // MarkMessageAsEnum.SEEN => It will mark all messages as seen
     // MarkMessageAsEnum.UNREAD => It will mark all messages as unread
     // MarkMessageAsEnum.UNSEEN => It will mark all messages as unseen
     markAs: MarkMessageAsEnum.Read
  );
  ```
</CodeGroup>

### Fetch All Feeds

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: feedsData } = await novu.feeds.get();
  ```
</CodeGroup>


# Angular Component
Source: https://v0.x-docs.novu.co/notification-center/client/angular



The `@novu/notification-center-angular` package provides an Angular component wrapper over the Notification Center Web Component that you can use to integrate the notification center into your Angular application.

## Installation

<Tip>Novu supports Angular version 15 and higher.</Tip>

<CodeGroup>
  ```bash pnpm theme={null}
  pnpm i @novu/notification-center-angular
  ```

  ```bash npm theme={null}
  npm i @novu/notification-center-angular
  ```

  ```bash yarn theme={null}
  yarn add @novu/notification-center-angular
  ```
</CodeGroup>

## Example usage

Module:

```tsx theme={null}
import { NotificationCenterModule } from '@novu/notification-center-angular';

@NgModule({
  imports: [..., NotificationCenterModule],
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
})
export class TheModule {}
```

Component:

```tsx theme={null}
import { Component } from "@angular/core";
import { environment } from "../environments/environment";

@Component({
  selector: "my-component",
  templateUrl: "./component.html",
})
export class AppComponent {
  subscriberId = environment.subscriberId;
  applicationIdentifier = environment.applicationIdentifier;

  sessionLoaded = (data: unknown) => {
    console.log("loaded", { data });
  };
}
```

Component HTML template:

```html theme={null}
<notification-center-component
  [subscriberId]="subscriberId"
  [applicationIdentifier]="applicationIdentifier"
  [sessionLoaded]="sessionLoaded"
></notification-center-component>
```

## Props

The `notification-center-component` accepts the same set of props as the [web component](/notification-center/client/web-component).

<Tip>
  You may need to add `"allowSyntheticDefaultImports": true` in tsconfig.json for the web component's React imports to work correctly.
</Tip>

## Example

* [Angular Notification Center Example Repo](https://github.com/novuhq/examples/tree/main/novu-angular-notification-center)
* [Example Source Code 🔗](https://github.com/novuhq/examples/tree/main/novu-angular-notification-center)


# Headless API Reference
Source: https://v0.x-docs.novu.co/notification-center/client/headless/api-reference



This page contains the complete documentation about the Headless Notification Center package. You can find here the list of all the methods that you can use.

## initializeSession

To use the headless service, you'll need to initialize the session first. This sets the token and starts the socket listener service.

```typescript theme={null}
headlessService.initializeSession({
  listener: (result: FetchResult<ISession>) => {
    console.log(result);
  },
  onSuccess: (session: ISession) => {
    console.log(session);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IInitializeSession {
  listener: (result: FetchResult<ISession>) => void;
  onSuccess?: (session: ISession) => void;
  onError?: (error: unknown) => void;
}
```

## fetchOrganization

Fetches the details of the current organization

```typescript theme={null}
headlessService.fetchOrganization({
  listener: (result: FetchResult<IOrganizationEntity>) => {
    console.log(result);
  },
  onSuccess: (organization: IOrganizationEntity) => {
    console.log(organization);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchOrganization {
  listener: (result: FetchResult<IOrganizationEntity>) => void;
  onSuccess?: (session: IOrganizationEntity) => void;
  onError?: (error: unknown) => void;
}
```

## fetchUnseenCount

Fetches the count of unseen messages

```typescript theme={null}
headlessService.fetchUnseenCount({
  listener: (result: FetchResult<{ count: number }>) => {
    console.log(result);
  },
  onSuccess: (data: { count: number }) => {
    console.log(data);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchUnseenCount {
  listener: (result: FetchResult<{ count: number }>) => void;
  onSuccess?: (data: { count: number }) => void;
  onError?: (error: unknown) => void;
}
```

## fetchUnreadCount

Fetches the count of unread messages

```typescript theme={null}
headlessService.fetchUnreadCount({
  listener: (result: FetchResult<{ count: number }>) => {
    console.log(result);
  },
  onSuccess: (data: { count: number }) => {
    console.log(data);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchUnreadCount {
  listener: (result: FetchResult<{ count: number }>) => void;
  onSuccess?: (data: { count: number }) => void;
  onError?: (error: unknown) => void;
}
```

## listenNotificationReceive

Listens to a new notification being added. Can be used to retrieve a new notification in real-time and trigger UI changes.

```typescript theme={null}
headlessService.listenNotificationReceive({
  listener: (message: IMessage) => {
    console.log(JSON.stringify(message));
  },
});
```

### method args interface

```typescript theme={null}
interface IListenNotificationReceive {
  listener: (message: IMessage) => void;
}
```

## listenUnseenCountChange

Listens to the changes of the unseen count. Can be used to get real time count of the unseen messages.

```typescript theme={null}
headlessService.listenUnseenCountChange({
  listener: (unseenCount: number) => {
    console.log(unseenCount);
  },
});
```

### method args interface

```typescript theme={null}
interface IListenUnseenCountChanget {
  listener: (unseenCount: number) => void;
}
```

## listenUnreadCountChange

Listens to the changes of the unread count. Can be used to get real time count of the unread messages.

```typescript theme={null}
headlessService.listenUnreadCountChange({
  listener: (unreadCount: number) => {
    console.log(unreadCount);
  },
});
```

### method args interface

```typescript theme={null}
interface IListenUnreadCountChanget {
  listener: (unreadCount: number) => void;
}
```

## fetchNotifications

Retrieves the list of notifications for the subscriber. Can also be used to get the notifications of a particular tab.

```typescript theme={null}
headlessService.fetchNotifications({
  listener: (result: FetchResult<IPaginatedResponse<IMessage>>) => {
    console.log(result);
  },
  onSuccess: (response: IPaginatedResponse<IMessage>) => {
    console.log(
      response.data,
      response.page,
      response.totalCount,
      response.pageSize
    );
  },
  page: pageNumber,
  query: { 
    feedIdentifier: "feedId", 
    read: false, 
    seen: true, 
    // payload sent while triggering the workflow
    payload: {
      message : "Notification message",
      type: "product",
    } 
  },
  storeId: "storeId",
});
```

### method args interface

```typescript theme={null}
interface IFetchNotifications {
  page?: number;
  storeId?: string;
  query?: IStoreQuery;
  listener: (result: FetchResult<IPaginatedResponse<IMessage>>) => void;
  onSuccess?: (messages: IPaginatedResponse<IMessage>) => void;
  onError?: (error: unknown) => void;
}
```

## fetchUserPreferences

Fetches the user [preferences](/subscribers/preferences)

```typescript theme={null}
headlessService.fetchUserPreferences({
  listener: (result: FetchResult<IUserPreferenceSettings[]>) => {
    console.log(result);
  },
  onSuccess: (settings: IUserPreferenceSettings[]) => {
    console.log(settings);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchUserPreferences {
  listener: (result: FetchResult<IUserPreferenceSettings[]>) => void;
  onSuccess?: (settings: IUserPreferenceSettings[]) => void;
  onError?: (error: unknown) => void;
}
```

## updateUserPreferences

Updates the user [preferences](/subscribers/preferences).

```typescript theme={null}
headlessService.updateUserPreferences({
  listener: (
    result: UpdateResult<
      IUserPreferenceSettings,
      unknown,
      IUpdateUserPreferencesVariables
    >
  ) => {
    console.log(result);
  },
  onSuccess: (settings: IUserPreferenceSettings) => {
    console.log(settings);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  templateId: "templateId",
  channelType: "SMS",
  checked: true,
});
```

### method args interface

```typescript theme={null}
interface IUpdateUserPreferences {
  templateId: IUpdateUserPreferencesVariables["templateId"];
  channelType: IUpdateUserPreferencesVariables["channelType"];
  checked: IUpdateUserPreferencesVariables["checked"];
  listener: (
    result: UpdateResult<
      IUserPreferenceSettings,
      unknown,
      IUpdateUserPreferencesVariables
    >
  ) => void;
  onSuccess?: (settings: IUserPreferenceSettings) => void;
  onError?: (error: unknown) => void;
}
```

## markNotificationsAsRead

Mark a single or multiple notifications as read using the message id.

```typescript theme={null}
headlessService.markNotificationsAsRead({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: ["messageOne", "messageTwo"],
});
```

### method args interface

```typescript theme={null}
interface IMarkNotificationsAsRead {
  messageId: IMessageId;
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## markNotificationsAsSeen

Mark a single or multiple notifications as seen using the message id.

```typescript theme={null}
headlessService.markNotificationsAsSeen({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: ["messageOne", "messageTwo"],
});
```

### method args interface

```
interface IMarkNotificationsAsSeen {
  messageId: IMessageId;
  listener: (result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}

```

## markNotificationsAs

Mark a single or multiple notifications using the message id.

```typescript theme={null}
headlessService.markNotificationsAs({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: ["messageOne", "messageTwo"],
  mark: { seen: true, read: true };
});
```

### method args interface

```typescript theme={null}
interface IMarkNotificationsAs {
  messageId: IMessageId;
  mark: { seen?: boolean; read?: boolean };
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## removeNotification

Removes a single notification using the message id.

```typescript theme={null}
headlessService.removeNotification({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: string }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: "messageOne",
});
```

### method args interface

```typescript theme={null}
interface IRemoveNotification {
  messageId: string;
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: string }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## removeNotifications

<Note>This method is available from version 0.23.1</Note>

Removes multiple notifications using array of message ids (limit of 100).

```typescript theme={null}
headlessService.removeNotifications({
  listener: (
    result: UpdateResult<void, unknown, { messageIds: string[] }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageIds: ["message_id_1", "message_id_2" ],
});
```

### method args interface

```typescript theme={null}
interface IRemoveNotification {
  messageIds: string[];
  listener: (
    result: UpdateResult<void, unknown, { messageIds: string[] }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## removeAllNotifications

Removes all notifications. Can be used to remove all notifications of a feed by passing the `feedId`

```typescript theme={null}
headlessService.removeAllNotifications({
  listener: (result: UpdateResult<void, unknown, undefined>) => {
    console.log(result);
  },
  onSuccess: () => {
    console.log("success");
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  feedId: "feedOne",
});
```

### method args interface

```typescript theme={null}
interface IRemoveAllNotifications {
  feedId?: string;
  listener: (result: UpdateResult<void, unknown, undefined>) => void;
  onSuccess?: () => void;
  onError?: (error: unknown) => void;
}
```

## updateAction

Updates the action button for the notifications.

```typescript theme={null}
headlessService.updateAction({
  listener: (
    result: UpdateResult<IMessage, unknown, IUpdateActionVariables>
  ) => {
    console.log(result);
  },
  onSuccess: (data: IMessage) => {
    console.log(data);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: "messageOne",
  actionButtonType: "primary",
  status: "done",
  payload: {
    abc: "def",
  },
});
```

### method args interface

```typescript theme={null}
interface IUpdateAction {
  messageId: IUpdateActionVariables["messageId"];
  actionButtonType: IUpdateActionVariables["actionButtonType"];
  status: IUpdateActionVariables["status"];
  payload?: IUpdateActionVariables["payload"];
  listener: (
    result: UpdateResult<IMessage, unknown, IUpdateActionVariables>
  ) => void;
  onSuccess?: (data: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## markAllMessagesAsRead

Mark subscriber's all unread messages as read. Can be used to mark all messages as read of a single or multiple feeds by passing the `feedId`

```typescript theme={null}
headlessService.markAllMessagesAsRead({
  listener: (result: UpdateResult<number, unknown, undefined>) => {
    console.log(result);
  },
  onSuccess: (count: number) => {
    console.log(count);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  feedId: ["feedOne", "feedTwo"],
});
```

### method args interface

```typescript theme={null}
interface IMarkAllMessagesAsRead {
  listener: (result: UpdateResult<number, unknown, undefined>) => void;
  onSuccess?: (count: number) => void;
  onError?: (error: unknown) => void;
  feedId?: IFeedId;
}
```

## markAllMessagesAsSeen

Mark subscriber's all unread messages as seen. Can be used to mark all messages as seen of a single or multiple feeds by passing the `feedId`

```typescript theme={null}
headlessService.markAllMessagesAsSeen({
  listener: (result: UpdateResult<number, unknown, undefined>) => {
    console.log(result);
  },
  onSuccess: (count: number) => {
    console.log(count);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  feedId: ["feedOne", "feedTwo"],
});
```

### method args interface

```typescript theme={null}
interface IMarkAllMessagesAsSeen {
  listener: (result: UpdateResult<number, unknown, undefined>) => void;
  onSuccess?: (count: number) => void;
  onError?: (error: unknown) => void;
  feedId?: IFeedId;
}
```

## Types and Interfaces

```typescript theme={null}
interface IHeadlessServiceOptions {
  backendUrl?: string;
  socketUrl?: string;
  applicationIdentifier: string;
  subscriberId?: string;
  subscriberHash?: string;
  config?: {
    retry?: number;
    retryDelay?: number;
  };
}

interface ISession {
  token: string;
  profile: ISubscriberJwt;
}

interface ISubscriberJwt {
  _id: string;
  firstName: string;
  lastName: string;
  email: string;
  subscriberId: string;
  organizationId: string;
  environmentId: string;
  aud: "widget_user";
}

interface IUpdateUserPreferencesVariables {
  templateId: string;
  channelType: string;
  checked: boolean;
}

enum ButtonTypeEnum {
  PRIMARY = "primary",
  SECONDARY = "secondary",
  CLICKED = "clicked",
}

enum MessageActionStatusEnum {
  PENDING = "pending",
  DONE = "done",
}

interface IUpdateActionVariables {
  messageId: string;
  actionButtonType: ButtonTypeEnum;
  status: MessageActionStatusEnum;
  payload?: Record<string, unknown>;
}

type FetchResult<T = unknown> = Pick<
  QueryObserverResult<T>,
  "data" | "error" | "status" | "isLoading" | "isFetching" | "isError"
>;

type UpdateResult<
  TData = unknown,
  TError = unknown,
  TVariables = unknown
> = Pick<
  MutationObserverResult<TData, TError, TVariables>,
  "data" | "error" | "status" | "isLoading" | "isError"
>;

type IMessageId = string | string[];
type IFeedId = string | string[];
```

<Tip>
  QueryObserverResult and MutationObserverResult are imported from
  the `@tanstack/query-core` library.
</Tip>


# Get Started
Source: https://v0.x-docs.novu.co/notification-center/client/headless/get-started



The headless version of Novu's notification library package provides users with a lightweight solution for integrating notification functionality into their web applications. With just the essential API methods, users can easily incorporate our notification system into any framework or vanilla JavaScript project, without being constrained by our default UI or dependencies.

## Installation

```bash theme={null}
npm install @novu/headless
```

Then, in your project import the headless service:

```
import { HeadlessService, FetchResult, ISession } from '@novu/headless';
```

## Initialize the session

To use the headless service and its features, you'll need to first initialize the session:

```tsx theme={null}
const headlessService = new HeadlessService({
  applicationIdentifier: "APPLICATION_IDENTIFIER",
  subscriberId: "SUBSCRIBER_ID",
});

headlessService.initializeSession({
  listener: (res: FetchResult<ISession>) => {
    console.log(res);
  },
  onSuccess: (session: ISession) => {
    console.log(session);
  },
  onError: (error) => {
    console.error(error);
  },
});
```

## Use your own backend and socket url

By default, Novu's hosted services of API and socket are used. Should you want, you could override them and configure your own.

```tsx theme={null}
const headlessService = new HeadlessService({
  applicationIdentifier: "APPLICATION_IDENTIFIER",
  subscriberId: "SUBSCRIBER_ID",
  backendUrl: "YOUR_BACKEND_URL",
  socketUrl: "YOUR_SOCKET_URL",
});

headlessService.initializeSession({
  listener: (session) => {
    console.log(session);
  },
  onSuccess: (session) => {
    console.log(session);
  },
  onError: (error) => {
    console.error(error);
  },
});
```

## Fetch Notifications

```jsx theme={null}
import { IPaginatedResponse, IMessage } from "@novu/headless";

headlessService.fetchNotifications({
  listener: ({ data, error, isError, isFetching, isLoading, status }) => {
    console.log({ data, error, isError, isFetching, isLoading, status });
  },
  onSuccess: (response: IPaginatedResponse<IMessage>) => {
    console.log(
      response.data,
      response.page,
      response.totalCount,
      response.pageSize
    );
  },
  page: 1, // page number to be fetched
});
```

<Note>fetchNotifications and other methods of the headless service should be used after initializing the session using headlessService.initializeSession</Note>

## HMAC Encryption

To use the Hash-Based Message Authentication Codes pass the HMAC code to the headless service:

```typescript theme={null}
const headlessService = new HeadlessService({
  applicationIdentifier: "APP_ID_FROM_ADMIN_PANEL",
  subscriberId: "USER_ID",
  subscriberHash: "HASHED_SUBSCRIBER_ID",
});
```

## Realtime Sockets

Novu headless library provides listenUnseenCountChange API to listen to real-time socket changes and get updates about new notifications added to the user's feed.

### unseen count changes

```typescript theme={null}
headlessService.listenUnseenCountChange({
  // this will run every time there's a change in the `unseen_count` in real-time
  listener: (unseenCount: number) => {
    console.log(unseenCount);
  },
});
```

### unread count changes

```typescript theme={null}
headlessService.listenUnreadCountChange({
  // this will run every time there's a change in the `unread_count` in real-time
  listener: (unreadCount: number) => {
    console.log(unreadCount);
  },
});
```

<Tip>
  If you're ready to start using the Headless Notification Center, check out our [guide!](/guides/headless-notification-center-guide)
</Tip>

[Explore Implementation of the Headless Library in an App](https://github.com/novuhq/novu-headless-demo-app)

[Headless Demo](https://headlessdemo.vercel.app)

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="How to use headless library for multiple users? ">
    We have `headless.initializeSession` method to generate token and initialize the session. If user log out and new user login, then calling again this method with second user subscriberId will generate new token and new session.
  </Accordion>

  <Accordion title="Can headless be used with mobile based platforms like flutter and react native?">
    Currently, headless can not be used with react native and flutter. Checkout the progress on mobile platform support on github issue [#4499](https://github.com/novuhq/novu/issues/4499).
  </Accordion>
</AccordionGroup>


# Iframe Embed
Source: https://v0.x-docs.novu.co/notification-center/client/iframe



If you are using a (currently) unsupported client framework, you can use our embedded script. This will generate the notification center inside an iframe

```html theme={null}
<script>
  (function (n, o, t, i, f) {
    n[i] = {};
    var m = ["init", "on"];
    n[i]._c = [];
    m.forEach(
      (me) =>
        (n[i][me] = function () {
          n[i]._c.push([me, arguments]);
        })
    );
    var elt = o.createElement(f);
    elt.type = "text/javascript";
    elt.async = true;
    elt.src = t;
    var before = o.getElementsByTagName(f)[0];
    before.parentNode.insertBefore(elt, before);
  })(
    window,
    document,
    "https://embed.novu.co/embed.umd.min.js",
    "novu",
    "script"
  );

  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
    },
    {
      subscriberId: "SUBSCRIBER_ID",
      email: "SUBSCRIBER_EMAIL",
      first_name: "SUBSCRIBER_FIRST_NAME",
      last_name: "SUBSCRIBER_LAST_NAME",
    }
  );
</script>
```

Replace the selectors for the bell icon and the unseen badge within your code. Let's take a look at this example code:

```html theme={null}
<nav>
  <div id="notification-bell">
    <i class="fa fa-bell"></i>
    <span id="unseen-badge"></span>
  </div>
</nav>
```

## Customizing the dropdown position

Optionally, the embedded init script receives a position object, you can use this to specify the `left` and `top` position of the notification center.

```html theme={null}
<script>
  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      position: {
        top: "50px",
        left: "100px",
      },
    },
    {
      ...subscriberProps,
    }
  );
</script>
```

## Customizing the theme

The notification center component can be customized by passing a `theme` to the init script. Checkout all possible theme [properties](/notification-center/client/react/api-reference).

```html theme={null}
<script>
  const customTheme = {
    light: {
      layout: {
        background: "red",
      },
    },
  };

  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      theme: customTheme,
    },
    {
      ...subscriberProps,
    }
  );
</script>
```

## Customizing the UI language

The language of the UI can be customized by passing an `i18n` component to the init script. More information on all possible [properties](/notification-center/client/react/customization#customize-the-ui-language).

```html theme={null}
<script>
  const customLanguage = {
    lang: "en",
    translations: {
      notifications: "My custom notifications!",
    },
  };

  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      i18n: customLanguage,
    },
    {
      ...subscriberProps,
    }
  );
</script>
```

## Handle User Interaction

In order to handle certain events like the user clicking on the notification, or clicking on an action button inside a notification, you can listen for these events and handle them accordingly.

```html theme={null}
<script>
  novu.on("notification_click", (notification) => {
    // do custom logic here
  });

  novu.on("action_click", ({ templateIdentifier, type, notification }) => {
    // do custom logic here
  });
</script>
```

## Enabling HMAC Encryption

In order to enable Hash-Based Message Authentication Codes, you need to visit the admin panel's In-App settings page and enable HMAC encryption for your environment.

The next step would be to generate an HMAC encrypted subscriberId on your backend:

```javascript theme={null}
import { createHmac } from "crypto";

const hmacHash = createHmac("sha256", process.env.NOVU_API_KEY)
  .update(subscriberId)
  .digest("hex");
```

Then pass the created HMAC to your client side application forward it to the embed initialization script:

```html theme={null}
<script>
  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      position: {
        top: "50px",
        left: "100px",
      },
    },
    {
      subscriberId: "SUBSCRIBER_ID_PLAIN_VALUE",
      subscriberHash: "SUBSCRIBER_ID_HASH_VALUE",
    }
  );
</script>
```

## Example

[![Edit novu-iframe-nc](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/novu-iframe-nc-t9ns9d?fontsize=14\&hidenavigation=1\&theme=dark)

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="The notification bell is not showing in the iframe.">
    We use font awesome bell icon. Make sure you have added the font awesome CSS cdn link in the head tag.

    ```html theme={null}
    <link
      rel="stylesheet"
      href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css"
      integrity="sha512-iecdLmaskl7CVkqkXNQ/ZH/XLlvWZOJyj7Yy7tcenmpD1ypASozpmT/E0iPtmFIB46ZmdtAc9eNBvH0H/ZpiBw=="
      crossorigin="anonymous"
      referrerpolicy="no-referrer"
    />
    ```
  </Accordion>
</AccordionGroup>


# API Reference
Source: https://v0.x-docs.novu.co/notification-center/client/react/api-reference



## React Notification Center API Reference

This page contains complete documentation about the React Notification Center package. You can find here the list of all the components, hooks, and props that you can use.

## Components

Components are the building blocks of the React Notification Center package. They are used to build the UI of the notification center.

## NovuProvider

The NovuProvider is the root component of the React Notification Center package. It is used to wrap the components code and provide the notifications feed context to all its children.
It's responsible for establishing the notification center session, managing the web socket connection, and fetching the notifications feed.

| Prop                    | Type                                                                           | Description                                                                                                                                                                                                                                                                                                                                                                     |
| ----------------------- | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| backendUrl              | string (optional)                                                              | The custom backend URL, your own deployed instance of the API. The default is [https://api.novu.co.app/](https://api.novu.co.app/).                                                                                                                                                                                                                                             |
| socketUrl               | string (optional)                                                              | The custom socket URL, your own deployed instance of the WS app. The default is [https://ws.novu.co/](https://ws.novu.co/).                                                                                                                                                                                                                                                     |
| applicationIdentifier   | string                                                                         | The app id is taken from the Novu Settings -> API Keys tab.                                                                                                                                                                                                                                                                                                                     |
| subscriberId            | string                                                                         | The unique user id from your system.                                                                                                                                                                                                                                                                                                                                            |
| subscriberHash          | string (optional)                                                              | The HMAC encrypted subscriberId. Read about [hmac encryption](/notification-center/client/react/get-started#hmac-encryption)                                                                                                                                                                                                                                                    |
| stores                  | [IStore](#store-interface) (optional)                                          | The connection object between feed and notification center tab.                                                                                                                                                                                                                                                                                                                 |
| i18n                    | [ITranslationEntry \| ITranslationContent](#i18nlanguage-interface) (optional) | The prop allows to configure the UI language.                                                                                                                                                                                                                                                                                                                                   |
| styles                  | [NotificationCenterStyles](#styles-interface) (optional)                       | The prop allowing to style the notification center. It's based on the CSSInterpolation object from the [@emotion/css](https://emotion.sh/docs/@emotion/css#object-styles) package.                                                                                                                                                                                              |
| initialFetchingStrategy | [IFetchingStrategy](#fetching-strategy-interface) (optional)                   | The fetching strategy. By default notifications feed and user preferences are not fetched until the notification center is opened. You might need to tweak this configuration when building a custom UI and if you need to fetch notifications right away. Also it's possible to change it when some action happens using the useNovuContext hook and setFetchingStrategy prop. |
| children                | object                                                                         | The ReactNode object type, the "consumer" of the NovuProvider context.                                                                                                                                                                                                                                                                                                          |
| onLoad                  | [function](#props-interface) (optional)                                        | The function that is called with an organization object after the notification center session is initialized.                                                                                                                                                                                                                                                                   |

### Props interface

```typescript theme={null}
interface INovuProviderProps {
  backendUrl?: string;
  socketUrl?: string;
  applicationIdentifier: string;
  subscriberId?: string;
  subscriberHash?: string;
  stores?: IStore[];
  i18n?: I18NLanguage | ITranslationEntry;
  styles?: INotificationCenterStyles;
  initialFetchingStrategy?: Partial<IFetchingStrategy>;
  children: React.ReactNode;
  onLoad?: (data: { organization: IOrganizationEntity }) => void;
}
```

### Store interface

```typescript theme={null}
interface IStore {
  storeId: string;
  query?: IStoreQuery;
}

interface IStoreQuery {
  feedIdentifier?: string | string[];
  seen?: boolean;
  read?: boolean;
  limit?: number; 
  payload?: Record<string, unknown>;
}
```

### I18NLanguage interface

```typescript theme={null}
type I18NLanguage = 'en' | 'de' ...;

interface ITranslationContent {
  readonly notifications: string;
  readonly markAllAsRead: string;
  readonly poweredBy: string;
  readonly settings: string;
  readonly removeMessage: string;
  readonly markAsRead: string;
  readonly markAsUnRead: string;
}

interface ITranslationEntry {
  readonly translations: Partial<ITranslationContent>;
  readonly lang: string;
}

```

### Styles interface

```typescript theme={null}
interface NotificationCenterStyles {
  bellButton?: ObjectWithRoot<{
    dot?: CSSFunctionOrObject;
  }>;
  unseenBadge?: CSSFunctionOrObject;
  popover?: {
    arrow?: CSSFunctionOrObject;
    dropdown?: CSSFunctionOrObject;
  };
  loader?: ObjectWithRoot;
  layout?: ObjectWithRoot;
  header?: ObjectWithRoot<{
    title?: CSSFunctionOrObject;
    markAsRead?: CSSFunctionOrObject;
    cog?: CSSFunctionOrObject;
    backButton?: CSSFunctionOrObject;
  }>;
  tabs?: {
    tabsList?: CSSFunctionOrObject;
    tab?: CSSFunctionOrObject;
    tabLabel?: CSSFunctionOrObject;
    tabIcon?: CSSFunctionOrObject;
  };
  accordion?: {
    item?: CSSFunctionOrObject;
    content?: CSSFunctionOrObject;
    control?: CSSFunctionOrObject;
    chevron?: CSSFunctionOrObject;
  };
  switch?: ObjectWithRoot<{
    input?: CSSFunctionOrObject;
    track?: CSSFunctionOrObject;
    thumb?: CSSFunctionOrObject;
  }>;
  footer?: ObjectWithRoot<{
    title?: CSSFunctionOrObject;
  }>;
  notifications?: ObjectWithRoot<{
    listItem?: {
      read?: CSSFunctionOrObject;
      unread?: CSSFunctionOrObject;
      layout?: CSSFunctionOrObject;
      contentLayout?: CSSFunctionOrObject;
      title?: CSSFunctionOrObject;
      timestamp?: CSSFunctionOrObject;
      dotsButton?: CSSFunctionOrObject;
      buttons?: ObjectWithRoot<{
        primary?: CSSFunctionOrObject;
        secondary?: CSSFunctionOrObject;
      }>;
    };
  }>;
  actionsMenu?: {
    arrow?: CSSFunctionOrObject;
    dropdown?: CSSFunctionOrObject;
    item?: CSSFunctionOrObject;
  };
  preferences?: ObjectWithRoot<{
    item?: {
      title?: CSSFunctionOrObject;
      channels?: CSSFunctionOrObject;
      divider?: CSSFunctionOrObject;
      content?: {
        icon?: CSSFunctionOrObject;
        channelLabel?: CSSFunctionOrObject;
        success?: CSSFunctionOrObject;
      };
    };
  }>;
}

type CSSFunctionInterpolation = (args: {
  theme: INovuTheme;
  common: ICommonTheme;
  colorScheme: ColorScheme;
}) => CSSInterpolation;

type CSSFunctionOrObject = CSSFunctionInterpolation | CSSInterpolation;

type ObjectWithRoot<T = {}> = T & {
  root: CSSFunctionOrObject;
};
```

<Accordion title="How to use the Styles Interface?">
  To use the Styles Interface, you need to identify the property you need to modify to achieve your desired look and pass it as an object in the `styles` prop.

  <br />

  As listed in the [Styles Interface](/notification-center/client/react/api-reference#styles-interface), the notification center is made up of a number of components which can each be individually customized.

  <br />

  You can also check out our [docs on customizing styles](https://docs.novu.co/notification-center/client/react/api-reference#styles-interface) to see how to define styles for various components that make up the notification center.

  <br />

  #### Let's take an example to see this in action:

  By default, this is how the notification center looks:

  <Frame>
    <img />
  </Frame>

  Say, you wanted the text color to match the accent color. You just need to go over to the [docs on customizing styles](https://docs.novu.co/notification-center/client/react/api-reference#styles-interface) and find out which property needs to be modified. In our case, we need to change the `color` property as evident here:

  <Frame>
    <img />
  </Frame>

  Now, that we know which property needs to change, all we need to do is pass an object to the `styles` prop while maintaining the nesting of object keys:

  ```javascript theme={null}
  <div className='bell'>
      <NovuProvider
          subscriberId={process.env.REACT_APP_SUB_ID}
          applicationIdentifier={process.env.REACT_APP_APP_ID}

          styles={{ notifications: { listItem: { layout: { color: '#E3554D' } } } }}

      >
          <PopoverNotificationCenter >
              {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
          </PopoverNotificationCenter>
      </NovuProvider>
  </div >
  ```

  This gives us the desired result:

  <Frame>
    <img />
  </Frame>

  <Note>Please have a look at our [docs on customizing styles](https://docs.novu.co/notification-center/client/react/api-reference#styles-interface) to see how to define styles for various components of the notification center.</Note>
</Accordion>

### Fetching strategy interface

```typescript theme={null}
interface IFetchingStrategy {
  fetchUnseenCount: boolean;
  fetchOrganization: boolean;
  fetchNotifications: boolean;
  fetchUserPreferences: boolean;
}
```

## PopoverNotificationCenter

The floating popover component that appears when clicking on the [NotificationBell](#notificationbell) button. It renders the [NotificationCenter](#notificationcenter) component inside its content.

| Prop                       | Type                                            | Description                                                                                                                                                                                                  |
| -------------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| position                   | string (optional)                               | Position of the popover relative to the bell icon. It is based on the [Mantine Popover](https://mantine.dev/core/popover/?t=props). The default is set to `bottom-end`.                                      |
| offset                     | number (optional)                               | Gap between the Bell icon and Popover in px.                                                                                                                                                                 |
| colorScheme                | string                                          | The UI light or dark mode.                                                                                                                                                                                   |
| theme                      | [INovuTheme](#the-theme-interface) (optional)   | The theme object allowing you to override light and dark colors of the UI components. Deprecated for styling, please use the [styles](#styles-interface) prop on the NovuProvider.                           |
| tabs                       | [ITab](#the-tab-interface)(optional)            | Allows to define separate UI tabs for the notifications feed. The array of connection objects between the feed tab and [stores](#store-interface) (that you define on the NovuProvider) and feed identifier. |
| listItem                   | [ListItem](#the-list-item-interface) (optional) | The render function allowing you to define the custom element for the notification list item.                                                                                                                |
| showUserPreferences        | boolean (optional)                              | The flag that enables to show/hide the user preferences. By default it is enabled.                                                                                                                           |
| allowedNotificationActions | boolean (optional)                              | The flag that enables to show/hide the dots menu for actions performed on a notification. By default it is enabled.                                                                                          |
| onUrlChange                | function (optional)                             | The function that is called when the notification item has a CTA of type redirect and is clicked.                                                                                                            |
| onNotificationClick        | function (optional)                             | The function that is called when the notification item is clicked.                                                                                                                                           |
| onUnseenCountChanged       | function (optional)                             | The function that is called when the unseen notifications count changed.                                                                                                                                     |
| children                   | function                                        | The render function that allows you to define the custom bell button. It's called with an argument that has unseenCount prop the number of unseen notifications.                                             |
| header                     | function (optional)                             | The render function that allows you to define the custom header component.                                                                                                                                   |
| footer                     | function (optional)                             | The render function that allows you to define the custom footer component.                                                                                                                                   |
| emptyState                 | JSX.Element (optional)                          | The render function that allows you to define the custom component for the empty notifications list state.                                                                                                   |
| onActionClick              | function (optional)                             | The callback function triggered when the notification button is clicked.                                                                                                                                     |
| actionsResultBlock         | function (optional)                             | The render function that allows you to define the custom component that will be rendered after the notification button is clicked.                                                                           |
| onTabClick                 | function (optional)                             | The callback function triggered when the notifications feed tab changes.                                                                                                                                     |
| preferenceFilter           | function (optional)                             | The callback function triggered when filtering the subscriber preference.                                                                                                                                    |

### Props interface

```typescript theme={null}
interface IPopoverNotificationCenterProps {
  position?: PopoverProps["position"];
  offset?: number;
  colorScheme: ColorScheme;
  theme?: INovuThemePopoverProvider;
  tabs?: ITab[];
  listItem?: ListItem;
  showUserPreferences?: boolean;
  allowedNotificationActions?: boolean;
  onUrlChange?: (url: string) => void;
  onNotificationClick?: (notification: IMessage) => void;
  onUnseenCountChanged?: (unseenCount: number) => void;
  children: (props: INotificationBellProps) => JSX.Element;
  header?: () => JSX.Element;
  footer?: () => JSX.Element;
  emptyState?: JSX.Element;
  onActionClick?: (
    templateIdentifier: string,
    type: ButtonTypeEnum,
    message: IMessage
  ) => void;
  actionsResultBlock?: (
    templateIdentifier: string,
    messageAction: IMessageAction
  ) => JSX.Element;
  onTabClick?: (tab: ITab) => void;
  preferenceFilter?: (userPreference: IUserPreferenceSettings) => boolean;
}
```

More information about the [IMessage](#the-notification-imessage-model) interface, and the [theme](#the-theme-interface) interface.

### The tab interface

```typescript theme={null}
interface ITab {
  name: string;
  storeId: string;
}
```

### The list item interface

```typescript theme={null}
type ListItem = (
  message: IMessage,
  onActionButtonClick: (actionButtonType: ButtonTypeEnum) => void,
  onNotificationClick: () => void
) => JSX.Element;
```

## NotificationCenter

The component that renders the notifications feed and allows to update the user preferences.

| Prop                       | Type                                            | Description                                                                                                                                                                                                  |
| -------------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| colorScheme                | string                                          | The UI light or dark mode.                                                                                                                                                                                   |
| theme                      | [INovuTheme](#the-theme-interface) (optional)   | The theme object allowing you to override light and dark colors of the UI components. Deprecated for styling, please use the [styles](#styles-interface) prop on the NovuProvider.                           |
| tabs                       | [ITab](#the-tab-interface)(optional)            | Allows to define separate UI tabs for the notifications feed. The array of connection objects between the feed tab and [stores](#store-interface) (that you define on the NovuProvider) and feed identifier. |
| listItem                   | [ListItem](#the-list-item-interface) (optional) | The render function allowing you to define the custom element for the notification list item.                                                                                                                |
| showUserPreferences        | boolean (optional)                              | The flag that enables to show/hide the user preferences. By default it is enabled.                                                                                                                           |
| allowedNotificationActions | boolean (optional)                              | The flag that enables to show/hide the dots menu for actions performed on a notification. By default it is enabled.                                                                                          |
| onUrlChange                | function (optional)                             | The function that is called when the notification item has a CTA of type redirect and is clicked.                                                                                                            |
| onNotificationClick        | function (optional)                             | The function that is called when the notification item is clicked.                                                                                                                                           |
| onUnseenCountChanged       | function (optional)                             | The function that is called when the unseen notifications count changed.                                                                                                                                     |
| header                     | function (optional)                             | The render function that allows you to define the custom header component.                                                                                                                                   |
| footer                     | function (optional)                             | The render function that allows you to define the custom footer component.                                                                                                                                   |
| emptyState                 | JSX.Element (optional)                          | The render function that allows you to define the custom component for the empty notifications list state.                                                                                                   |
| onActionClick              | function (optional)                             | The callback function triggered when the notification button is clicked.                                                                                                                                     |
| actionsResultBlock         | function (optional)                             | The render function that allows you to define the custom component that will be rendered after the notification button is clicked.                                                                           |
| onTabClick                 | function (optional)                             | The callback function triggered when the notifications feed tab changes.                                                                                                                                     |
| preferenceFilter           | function (optional)                             | The callback function triggered when filtering the subscriber preference.                                                                                                                                    |

### Props interface

```typescript theme={null}
interface INotificationCenterProps {
  colorScheme: ColorScheme;
  theme?: INovuThemeProvider;
  tabs?: ITab[];
  listItem?: ListItem;
  showUserPreferences?: boolean;
  allowedNotificationActions?: boolean;
  onUrlChange?: (url: string) => void;
  onNotificationClick?: (notification: IMessage) => void;
  onUnseenCountChanged?: (unseenCount: number) => void;
  header?: () => JSX.Element;
  footer?: () => JSX.Element;
  emptyState?: JSX.Element;
  onActionClick?: (
    templateIdentifier: string,
    type: ButtonTypeEnum,
    message: IMessage
  ) => void;
  actionsResultBlock?: (
    templateIdentifier: string,
    messageAction: IMessageAction
  ) => JSX.Element;
  onTabClick?: (tab: ITab) => void;
  preferenceFilter?: (userPreference: IUserPreferenceSettings) => boolean;
}
```

## NotificationBell

The component that renders the notification bell with the unseen notifications count.

| Prop                       | Type                        | Description                                                  |
| -------------------------- | --------------------------- | ------------------------------------------------------------ |
| unseenCount                | number (optional)           | The number of unseen notifications.                          |
| unseenBadgeColor           | string or object (optional) | The unseen notifications count badge color.                  |
| unseenBadgeBackgroundColor | string (optional)           | The background color of the notification unseen count badge. |
| colorScheme                | string (optional)           | The UI light or dark mode.                                   |

### Props interface

```typescript theme={null}
interface INotificationBellProps {
  unseenCount?: number;
  unseenBadgeColor?: string | ISvgStopColor;
  unseenBadgeBackgroundColor?: string;
  colorScheme?: ColorScheme;
}

interface ISvgStopColor {
  stopColor?: string;
  stopColorOffset?: string;
}
```

## Hooks

### useNotifications

This hook that allows you to get the notifications feed data and unseen notifications count. The notifications are fetched only when the `fetchingStrategy.fetchNotifications` is set to true interface, check the `initialFetchingStrategy` prop on the [NovuProvider](#novuprovider) component.

```typescript theme={null}
const result = useNotifications();
```

`useNotifications` hook return interface

```typescript theme={null}
interface INotificationsContext {
  storeId: string;
  storeQuery: IStoreQuery;
  stores: IStore[];
  unseenCount: number;
  notifications: IMessage[];
  hasNextPage: boolean;
  isLoading: boolean;
  isFetching: boolean;
  isFetchingNextPage: boolean;
  setStore: (storeId?: string) => void;
  fetchNextPage: () => void;
  refetch: () => void;
  markNotificationAsRead: (messageId: string) => void;
  markNotificationAsUnRead: (messageId: string) => void;
  markNotificationAsSeen: (messageId: string) => void;
  markFetchedNotificationsAsRead: () => void;
  markFetchedNotificationsAsSeen: () => void;
  markAllNotificationsAsRead: () => void;
  markAllNotificationsAsSeen: () => void;
  removeMessage: (messageId: string) => void;
  removeAllMessages: (feedId?: string) => void;
}
```

Description of the `useNotifications` hook return interface properties

| Prop                           | Type                                             | Description                                                                                                           |
| ------------------------------ | ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| storeId                        | string                                           | active `storeId`                                                                                                      |
| stores                         | [IStore\[\]](#store-interface)                   | array of [IStore](#store-interface) passed to the [NovuProvider](#novuprovider).                                      |
| unseenCount                    | number                                           | unseen notifications (messages) count.                                                                                |
| notifications                  | [IMessage\[\]](#the-notification-imessage-model) | The feed notifications array.                                                                                         |
| hasNextPage                    | boolean                                          | flag indicating if the next notifications page to fetch is available.                                                 |
| isLoading                      | boolean                                          | flag indicating if the initial notifications fetch request is on the fly.                                             |
| isFetching                     | boolean                                          | flag indicating if the notifications are fetching including initial fetch.                                            |
| isFetchingNextPage             | boolean                                          | flag indicating if the next notifications page request in on the fly.                                                 |
| setStore                       | function                                         | function used to change the current notifications [IStore](#store-interface)                                          |
| fetchNextPage                  | function                                         | function that fires the fetch request for the next notifications page.                                                |
| refetch                        | function                                         | function used to refetch all the notifications, when multiple page requests were made it will refetch all of them.    |
| markNotificationAsRead         | function                                         | function takes the notification (message) `messageId` as an argument and marks that notification (message) as read.   |
| markNotificationAsUnRead       | function                                         | function takes the notification (message) `messageId` as an argument and marks that notification (message) as unread. |
| markNotificationAsSeen         | function                                         | function takes the notification (message) `messageId` as an argument and marks that notification (message) as seen.   |
| markFetchedNotificationsAsRead | function                                         | function marks all the fetched notifications as read.                                                                 |
| markFetchedNotificationsAsSeen | function                                         | function allowing you to mark all the fetched notifications as seen.                                                  |
| markAllNotificationsAsRead     | function                                         | function allowing you to mark all notifications as read.                                                              |
| markAllNotificationsAsSeen     | function                                         | function allowing you to mark notifications as seen.                                                                  |
| removeMessage                  | function                                         | function takes the notification (message) `messageId` as an argument and delete a notification.                       |
| removeAllMessages              | function                                         | The function allowing you to delete all notifications or a specific feed's (store's) notifications at once.           |

### useFetchNotifications

`useFetchNotifications` can fetche the notifications for a particular feed. It's a thin version of the `useNotifications` hook and is based on the `useInfiniteQuery` hook from the `react-query` library. Notifications can be filtered using `payload` property. Check all properties of [IStoreQuery](#store-interface) interface. The notifications are fetched only when the `fetchingStrategy.fetchNotifications` is set to true interface, check the `initialFetchingStrategy` prop on the [NovuProvider](#novuprovider) component.

```typescript theme={null}
const query: IStoreQuery = {
  limit: 10,
  payload: {
    key: "value"
  }
};

const onSuccess = (data: IPaginatedResponse<IMessage>) => {};

const onError = (error: Error) => {};

const {
  data: notificationsPages,
  hasNextPage,
  isLoading,
  isFetching,
  isFetchingNextPage,
  fetchNextPage,
  refetch,
} = useFetchNotifications({ query }, { onSuccess, onError });
```

`useFetchNotifications` hook return args

```typescript theme={null}
interface IUseFetchNotificationsArgs {
  onSuccess?: (data: IPaginatedResponse<IMessage>) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useInfiniteQuery hook
}

```

`useFetchNotifications` hook return interface

```typescript theme={null}
interface InfiniteData<TData> {
  pages: TData[];
  pageParams: unknown[];
}

interface IUseUnseenCountResult {
  data: InfiniteData<IPaginatedResponse<IMessage>>;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useInfiniteQuery hook result
}
```

### useUnseenCount

`useUnseenCount` returns the total unseen notifications count. Under the hood it uses the socket connection to get the unseen count updates.

```typescript theme={null}
interface ICountData {
  count: number;
}

const onSuccess = ({ count }: ICountData) => {};

const onError = (error: Error) => {};

const { data, isLoading, isError, error } = useUnseenCount({ onSuccess, onError });
```

`useUnseenCount` hook args interface

```typescript theme={null}
interface IUseUnseenCountArgs {
  onSuccess?: (data: ICountData) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useUnseenCount` hook return interface

```typescript theme={null}
interface IUseUnseenCountResult {
  data?: ICountData;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useSocket

`useSocket` hooks is used to get the reference to socket object.

```typescript theme={null}
const { socket } = useSocket();
```

`useSocket` return interface

```typescript theme={null}
interface ISocket {
  on: (eventName: string, callback: (data: any) => void) => void;
  off: (eventName: string) => void;
}
```

`useSocket` supported events

| Event                  | Description                                              |
| ---------------------- | -------------------------------------------------------- |
| notification\_received | Triggered when a new notification is received            |
| unseen\_count\_changed | Triggered when the count of unseen notifications changes |
| unread\_count\_changed | Triggered when the count of unread notifications changes |

### useNovuContext

`useNovuContext` hook is used to get the reference to the [NovuProvider](#novuprovider) context.

```typescript theme={null}
const result = useNovuContext();
```

`useNovuContext` hook return interface

```typescript theme={null}
interface INovuProviderContext {
  backendUrl?: string;
  subscriberId?: string;
  applicationIdentifier?: string;
  isSessionInitialized: boolean;
  socketUrl?: string;
  subscriberHash: string;
  apiService: ApiService;
  socket?: ISocket;
  fetchingStrategy: IFetchingStrategy;
  setFetchingStrategy: (strategy: Partial<IFetchingStrategy>) => void;
  onLoad: (data: { organization: IOrganizationEntity }) => void;
}
```

### useFeedUnseenCount

`useFeedUnseenCount` hook fetches the unseen count for a particular feed.

```typescript theme={null}
interface ICountData {
  count: number;
}

const query: IStoreQuery = {
  feedIdentifier: "product-updates"
};

const onSuccess = (data: ICountData) => {};

const onError = (error: Error) => {};

const result = useFeedUnseenCount({ query }, { onSuccess, onError });
```

`useFeedUnseenCount` hook args interface

```typescript theme={null}
interface IUseFeedUnseenCountArgs {
  onSuccess?: (data: ICountData) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useFeedUnseenCount` hook return interface

```typescript theme={null}
interface IUseFeedUnseenCountResult {
  data?: ICountData;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useFetchOrganization

`useFetchOrganization` hok fetches the current organization information.

```typescript theme={null}
interface IOrganizationEntity {
  _id: string;
  name: string;
  members: {
    _id: string;
    _userId?: string;
    user?: Pick<IUserEntity, 'firstName' | '_id' | 'lastName' | 'email'>;
    roles: MemberRoleEnum[];
    invite?: IMemberInvite;
    memberStatus: MemberStatusEnum;
  }[];
  branding?: {
    color: string;
    logo: string;
    fontColor: string;
    fontFamily: string;
    contentBackground: string;
    direction: 'ltr' | 'rtl';
  };
}

const onSuccess = (data: IOrganizationEntity) => {};

const onError = (error: Error) => {};

const result = useFetchOrganization({ onSuccess, onError });
```

`useFetchOrganization` hook args interface

```typescript theme={null}
interface IUseFetchOrganizationArgs {
  onSuccess?: (data: IOrganizationEntity) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useFetchOrganization` hook return interface

```typescript theme={null}
interface IUseFetchOrganizationResult {
  data?: IOrganizationEntity;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useFetchUserPreferences

`useFetchUserPreferences` hook fetches the user preferences.

```typescript theme={null}
const onSuccess = (data: IUserPreferenceSettings[]) => {};

const onError = (error: Error) => {};

const result = useFetchUserPreferences({ onSuccess, onError });
```

`useFetchUserPreferences` hook args interface

```typescript theme={null}
interface IUseFetchUserPreferencesArgs {
  onSuccess?: (data: IUserPreferenceSettings[]) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useFetchUserPreferences` hook return interface

```typescript theme={null}
interface IUseFetchUserPreferencesResult {
  data?: IUserPreferenceSettings[];
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useUpdateUserPreferences

`useUpdateUserPreferences` hook is used to update the user preferences.

```typescript theme={null}
interface IPreferenceChannels {
  email?: boolean;
  sms?: boolean;
  in_app?: boolean;
  chat?: boolean;
  push?: boolean;
}

interface IUserPreferenceSettings {
  template: { _id: string; name: string; critical: boolean };
  preference: { enabled: boolean; channels: IPreferenceChannels };
}

const onSuccess = (data: IUserPreferenceSettings) => {};

const onError = (error: Error) => {};

const { updateUserPreferences, isLoading, isError, error } = useUpdateUserPreferences({
  onSuccess,
  onError,
});
```

`useUpdateUserPreferences` hook args interface

```typescript theme={null}
interface IUserPreferencesArgs {
  onSuccess?: (data: IUserPreferenceSettings) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useUpdateUserPreferences` hook return interface

```typescript theme={null}
interface IUpdateUserPreferencesVariables {
  templateId: string; // workflowId of mongodbId type
  channelType: string;
  checked: boolean;
}

interface IUserPreferencesResult {
  updateUserPreferences: (variables: IUpdateUserPreferencesVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useUpdateAction

`useUpdateAction` hook can be used to update the notification action button status.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { updateAction, isLoading, isError, error } = useUpdateAction({ onSuccess, onError });
```

`useUpdateAction` hook args interface

```typescript theme={null}
interface IUseUpdateActionArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useUpdateAction` hook return interface

```typescript theme={null}
interface IUpdateActionVariables {
  messageId: string;
  actionButtonType: ButtonTypeEnum;
  status: MessageActionStatusEnum;
  payload?: Record<string, unknown>;
}

interface IUpdateActionResult {
  updateAction: (variables: IUpdateActionVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useMarkNotificationsAs

`useMarkNotificationsAs` hook that marks the notifications as read or seen.

```typescript theme={null}
const onSuccess = (data: IMessage[]) => {};

const onError = (error: Error) => {};

const { markNotificationsAs, isLoading, isError, error } = useMarkNotificationsAs({
  onSuccess,
  onError,
});
```

`useMarkNotificationsAs` hook args interface

```typescript theme={null}
interface IUseMarkNotificationsAsArgs {
  onSuccess?: (data: IMessage[]) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useMarkNotificationsAs` hook return interface

```typescript theme={null}
interface IMarkNotificationsAsVariables {
  messageId: IMessageId;
  seen: boolean;
  read: boolean;
}

interface IUseMarkNotificationsAsResult {
  markNotificationsAs: (args: IMarkNotificationsAsVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useRemoveNotification

`useRemoveNotification` hook allows you to remove a message. It will delete the message for the subscriber and will refetch the feed.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { removeNotification, isLoading, isError, error } = useRemoveNotification({
  onSuccess,
  onError,
});
```

`useRemoveNotification` hook args interface

```typescript theme={null}
interface IUseRemoveNotificationArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useRemoveNotification` hook return interface

```typescript theme={null}
interface IRemoveNotificationVariables {
  messageId: IMessageId;
}

interface IUseRemoveNotificationResult {
  removeNotification: (args: IRemoveNotificationVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useRemoveNotifications

<Note>This hook is available from version 0.23.1</Note>

`useRemoveNotifications` hook allows you to remove multiple messages with a limit of 100 messageIds in single call.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { removeNotifications, isLoading, isError, error } = useRemoveNotifications({
  onSuccess,
  onError,
});
```

`useRemoveNotifications` hook args interface

```typescript theme={null}
interface IUseRemoveNotificationArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useRemoveNotifications` hook return interface

```typescript theme={null}
interface IRemoveNotificationsVariables {
  messageIds: string[];
}

interface IUseRemoveNotificationResult {
  removeNotifications: (args: IRemoveNotificationsVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useRemoveAllNotifications

`useRemoveAllNotifications` hook allows you to remove all messages of all feeds. feedId can be used as param to delete only specific feed's messages.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { removeAllNotifications, isLoading, isError, error } = useRemoveAllNotifications({
  onSuccess,
  onError,
});
```

`useRemoveAllNotifications` hook args interface

```typescript theme={null}
interface IUseRemoveAllNotificationsArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useRemoveAllNotifications` hook return interface

```typescript theme={null}
interface IRemoveAllNotificationsVariables {
  feedId?: string;
}

interface IUseRemoveAllNotificationsResult {
  removeAllNotifications: (args: IRemoveAllNotificationsVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useTranslations

`useTranslations` hook allows you to get the reference to the [translations](/notification-center/client/react/customization#customize-the-ui-language) object.

```typescript theme={null}
const result = useTranslations();
```

`useTranslations` returns interface

```typescript theme={null}
interface ITranslations {
  lang: string;
  t: (key: string) => string;
  dateFnsLocale: () => Locale;
}
```

### useNovuTheme

`useNovuTheme` hook can be used to get the reference to the [theme](#the-theme-interface) object.

```typescript theme={null}
const result = useNovuTheme();
```

`useNovuTheme` hook return interface

```typescript theme={null}
interface INovuThemeProviderContext {
  theme: INovuTheme;
  common: ICommonTheme;
  colorScheme: ColorScheme;
}
```

#### The theme interface

```typescript theme={null}
interface INovuTheme {
  layout?: IThemeLayout;
  header?: IThemeHeader;
  popover?: IThemePopover;
  actionsMenu?: IThemeActionsMenu;
  notificationItem?: IThemeNotificationListItem;
  userPreferences?: IThemeUserPreferences;
  footer?: IThemeFooter;
  loaderColor?: string;
}
```

#### `IThemeLayout`

| Property                   | Default Value (Light Theme)            | Default Value - (Dark Theme)    |
| -------------------------- | -------------------------------------- | ------------------------------- |
| background                 | #FFFFFF                                | #1E1E26                         |
| boxShadow                  | 0px 5px 15px rgba(122, 133, 153, 0.25) | 0px 5px 20px rgba(0, 0, 0, 0.2) |
| wrapper.secondaryFontColor | #BEBECC                                | #525266                         |

#### `IThemeHeader`

| Property       | Default Value (Light Theme)                   | Default Value - (Dark Theme)                  |
| -------------- | --------------------------------------------- | --------------------------------------------- |
| badgeColor     | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) |
| badgeTextColor | #FFFFFF                                       | #FFFFFF                                       |
| fontColor      | #828299                                       | #FFFFFF                                       |

#### `IThemePopover`

| Property   | Default Value (Light Theme) | Default Value - (Dark Theme) |
| ---------- | --------------------------- | ---------------------------- |
| arrowColor | #FFFFFF                     | #1E1E26                      |

#### `IThemeNotificationListItem`

| Property                                | Default Value (Light Theme)                             | Default Value - (Dark Theme)                            |
| --------------------------------------- | ------------------------------------------------------- | ------------------------------------------------------- |
| seen.fontColor                          | #828299                                                 | #FFFFFF                                                 |
| seen.background                         | #F5F8FA                                                 | #23232B                                                 |
| seen.timeMarkFontColor                  | #BEBECC                                                 | #525266                                                 |
| unseen.fontColor                        | #828299                                                 | #FFFFFF                                                 |
| unseen.background                       | #FFFFFF                                                 | #292933                                                 |
| unseen.boxShadow                        | 0px 5px 15px rgba(122, 133, 153, 0.25)                  | 0px 5px 20px rgba(0, 0, 0, 0.2)                         |
| unseen.notificationItemBeforeBrandColor | linear-gradient(0deg,#FF512F 0%,#DD2476 100%)           | linear-gradient(0deg,#FF512F 0%,#DD2476 100%)           |
| unseen.timeMarkFontColor                | #828299                                                 | #828299                                                 |
| buttons.primary.backGroundColor         | linear-gradient(99deg,#DD2476 0% 0%, #FF512F 100% 100%) | linear-gradient(99deg,#DD2476 0% 0%, #FF512F 100% 100%) |
| buttons.primary.fontColor               | #FFFFFF                                                 | #FFFFFF                                                 |
| buttons.primary.removeCircleColor       | white                                                   | white                                                   |
| buttons.primary.fontFamily              | inherit                                                 | inherit                                                 |
| buttons.secondary.backGroundColor       | #F5F8FA                                                 | #3D3D4D                                                 |
| buttons.secondary.fontColor             | #525266                                                 | #FFFFFF                                                 |
| buttons.secondary.removeCircleColor     | #525266                                                 | #525266                                                 |
| buttons.secondary.fontFamily            | inherit                                                 | inherit                                                 |

#### `IThemeActionsMenu`

| Property        | Default Value (Light Theme) | Default Value - (Dark Theme) |
| --------------- | --------------------------- | ---------------------------- |
| dotsButtonColor | #A1A1B2                     | #525266                      |
| dropdownColor   | #FFFFFF                     | #292933                      |
| hoverColor      | #F5F8FA                     | #3D3D4D                      |
| fontColor       | #525266                     | #FFFFFF                      |

#### `IThemeUserPreferences`

| Property                                   | Default Value (Light Theme)                   | Default Value - (Dark Theme)                  |
| ------------------------------------------ | --------------------------------------------- | --------------------------------------------- |
| `settingsButtonColor`                      | #A1A1B2                                       | #525266                                       |
| `accordion.background`                     | #FFFFFF                                       | #292933                                       |
| `accordion.fontColor`                      | #525266                                       | #FFFFFF                                       |
| `accordion.secondaryFontColor`             | #828299                                       | #828299                                       |
| `accordion.boxShadow`                      | 0px 5px 15px rgba(122, 133, 153, 0.25)        | 0px 5px 20px rgba(0, 0, 0, 0.2)               |
| `accordion.arrowColor`                     | #828299                                       | #828299                                       |
| `accordion.arrowColor`                     | #EDF0F2                                       | #3D3D4D                                       |
| `accordionItem.fontColor.active`           | #525266                                       | #FFFFFF                                       |
| `accordionItem.fontColor.inactive`         | #BEBECC                                       | #828299                                       |
| `accordionItem.icon.active`                | #525266                                       | #FFFFFF                                       |
| `accordionItem.icon.inactive`              | #BEBECC                                       | #525266                                       |
| `accordionItem.switch.backgroundChecked`   | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) |
| `accordionItem.switch.backgroundUnchecked` | #BEBECC                                       | #3D3D4D                                       |
| `footer.logoTextColor`                     | #000000                                       | #FFFFFF                                       |
| `footer.logoPrefixFontColor`               | #A1A1B2                                       | #525266                                       |
| `loaderColor`                              | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) |

#### `IThemeFooter`

| Property            | Default Value (Light Theme) | Default Value - (Dark Theme) |
| ------------------- | --------------------------- | ---------------------------- |
| logoTextColor       | #000000                     | #FFFFFF                      |
| logoPrefixFontColor | #A1A1B2                     | #525266                      |

customization properties

| Property                   | type                                      | Default Value (Light Theme) | Default Value - (Dark Theme) |
| -------------------------- | ----------------------------------------- | --------------------------- | ---------------------------- |
| colorScheme                | string                                    | light                       | light                        |
| unseenBadgeColor           | string or [ISvgStopColor](#isvgstopcolor) | -                           | -                            |
| unseenBadgeBackgroundColor | string                                    | #FFFFFF                     | #1E1E26                      |

#### `ISvgStopColor`

| Property        | Default Value (Light Theme) | Default Value - (Dark Theme) |
| --------------- | --------------------------- | ---------------------------- |
| stopColor       | #FF512F                     | #FF512F                      |
| stopColorOffset | #DD2476                     | #DD2476                      |

## Others

### The notification `IMessage` model

`IMessage` model has the following properties:

| Property                  | Type                                      | Description                                                                                          |
| ------------------------- | ----------------------------------------- | ---------------------------------------------------------------------------------------------------- |
| \_id                      | string                                    | A unique Novu message identifier                                                                     |
| channel                   | [ChannelTypeEnum](#channeltypeenum)       | Use to specify the actual channel of this message (in\_app will be used here)                        |
| seen                      | boolean                                   | Whether the notification item was read by the user, changed when the user clicks on the notification |
| lastSeenDate              | ISODate                                   | When the user has last seen the notification                                                         |
| content                   | string                                    | An HTML string of the generated notification content with parsed and replaced variables              |
| templateIdentifier        | string                                    | A unique Novu workflow identifier                                                                    |
| payload                   | `Record<string, unknown>`                 | The payload object that was passed to the trigger even of the workflow.                              |
| createdAt                 | ISODate                                   | The creation date of the message                                                                     |
| cta.type                  | [ChannelCTATypeEnum](#channelctatypeenum) | The type of the CTA specified in the admin panel                                                     |
| cta.data.url              | string                                    | The redirect URL set in the admin panel, can be used to navigate on notification click               |
| cta.action.status         | boolean                                   | Indication whether the action occurred                                                               |
| cta.action.buttons        | [IMessageButton\[\]](#imessagebutton)     | Array of action buttons                                                                              |
| cta.action.result.payload | `Record<string, unknown>`                 | Payload object that send on updateAction method in useNotifications hook                             |
| cta.action.result.type    | [ButtonTypeEnum](#buttontypeenum)         | Type of the button                                                                                   |
| subscriber                | [SubscriberProps](#subscriberprops)       | Subscriber object that contains information about the subscriber                                     |

### SubscriberProps

| Property     | Type   | Description                                                         |
| ------------ | ------ | ------------------------------------------------------------------- |
| \_id         | string | Auto-generated identifier for the subscriber entity in the database |
| firstName    | string | First name of the subscriber                                        |
| subscriberId | string | identifier of the subscriber entity in the Novu Web Dashboard       |

### IMessageButton

| Property | Type                              | Description       |
| -------- | --------------------------------- | ----------------- |
| type     | [ButtonTypeEnum](#buttontypeenum) | Button type enum  |
| content  | string                            | Button inner text |

### ChannelCTATypeEnum

| Property | Value    |
| -------- | -------- |
| REDIRECT | redirect |

### ChannelTypeEnum

| Property | Value   |
| -------- | ------- |
| IN\_APP  | in\_app |
| EMAIL    | email   |
| SMS      | sms     |
| CHAT     | chat    |
| PUSH     | push    |

### ButtonTypeEnum

| Property  | Value     |
| --------- | --------- |
| PRIMARY   | primary   |
| SECONDARY | secondary |


# Customizing Notification Center
Source: https://v0.x-docs.novu.co/notification-center/client/react/customization

Learn how to customize the pre built notification center component partially or building your own notification center component from scratch using Novu provided hooks

## PopoverNotificationCenter Customization

`<PopoverNotificationCenter>` is a pre built notification center component that can be used to show notifications in your application. It is a popover component that can be placed anywhere in your application. A bell will appear on the page. On click of that bell, a popover will appear. Checkout all customizations and available [props](/notification-center/client/react/api-reference#popovernotificationcenter). If you are looking for a component without popover use regular `<NotificationCenter>` component. Checkout [props](/notification-center/client/react/api-reference#notificationcenter) of this component. Few selected customization options are explained below:-

### Implementing custom bell icon

It is common that you might have a special set of icons you use within your application and you will want to replace the default: `NotificationBell` coming from our library.

For this you can easily switch the `NotificationBell` with your own bell. Just make sure you pass the `unseenCount` param inside and use it accordingly.

```jsx theme={null}
<PopoverNotificationCenter colorScheme="dark">
  {({ unseenCount }) => (
    <CustomBell
      unseenCount={unseenCount}
      colorScheme="dark"
      unseenBadgeBackgroundColor="#FFFFFF"
      unseenBadgeColor="#FF0000"
    />
  )}
</PopoverNotificationCenter>
```

### Dark mode support

To support dark mode in your application the notification center component can receive a `colorScheme` prop that can receive either `dark` or `light` mode.

```tsx theme={null}
<PopoverNotificationCenter colorScheme={"dark" || "light"}>
  {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
</PopoverNotificationCenter>
```

### Popover positioning

Use `position`  and `offset` prop to position the popover relative to the Bell icon

```jsx theme={null}
<PopoverNotificationCenter position="left-start" offset={20}>
  {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
</PopoverNotificationCenter>
```

### Header, Footer and Empty state

Use `header`, `footer` and `emptyState` prop to customize the header, footer and empty state of notification center.

```jsx theme={null}
const Header = () => {
  return <span> My custom header </span>;
};

const Footer = () => {
  return <span> My custom footer </span>;
};

const EmptyState = () => {
  return <span> My custom empty state </span>;
};

<PopoverNotificationCenter
  colorScheme="dark"
  header={() => <Header />}
  footer={() => <Footer />}
  emptyState={<EmptyState />}
>
  {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
</PopoverNotificationCenter>;
```

### Notification item

Use the listItem prop to show custom notification items.

```jsx theme={null}
<PopoverNotificationCenter
  colorScheme={colorScheme}
  onNotificationClick={handlerOnNotificationClick}
  onActionClick={handlerOnActionClick}
  listItem={(
    notification,
    handleActionButtonClick,
    handleNotificationClick
  ) => {
    return (
      <a
        href="/"
        onClick={(e) => {
          e.preventDefault();
          handleNotificationClick();
        }}
      >
        {notification.content}
      </a>
    );
  }}
>
  {({ unseenCount }) => {
    return <NotificationBell unseenCount={unseenCount} />;
  }}
</PopoverNotificationCenter>
```

### Customize the UI language

If you want to use a language other than english for the UI, the `NovuProvider` component can accept an optional `i18n` prop.

```typescript theme={null}
<NovuProvider
  subscriberId={"USER_ID"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
  i18n="en"
>
  <PopoverNotificationCenter colorScheme="dark">
    {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
  </PopoverNotificationCenter>
</NovuProvider>
```

The `i18n` prop can accept 2 different types of values

* 2 letter language string

```typescript theme={null}
i18n = "en";
```

<Accordion title="Supported Language">
  * `af` (Afrikaans)
  * `am` (Amharic)
  * `ar` (Arabic)
  * `as` (Assamese)
  * `az` (Azerbaijani)
  * `ba` (Bashkir)
  * `be` (Belarusian)
  * `bg` (Bulgarian)
  * `bh` (Bihari)
  * `bn` (Bengali)
  * `bs` (Bosnian)
  * `ca` (Catalan)
  * `cs` (Czech)
  * `da` (Danish)
  * `de` (German)
  * `el` (Greek)
  * `en` (English)
  * `es` (Spanish)
  * `eu` (Basque)
  * `fa` (Farsi)
  * `fi` (Finnish)
  * `fr` (French)
  * `ga` (Irish)
  * `gl` (Galician)
  * `gu` (Gujarati)
  * `he` (Hebrew)
  * `hi` (Hindi)
  * `hr` (Croatian)
  * `hu` (Hungarian)
  * `hy` (Armenian)
  * `id` (Indonesian)
  * `ig` (Igbo)
  * `it` (Italian)
  * `ja` (Japanese)
  * `ka` (Kannada)
  * `kk` (Kazakh)
  * `km` (Khmer)
  * `ko` (Korean)
  * `ku` (Kurdish)
  * `lo` (Lao)
  * `lt` (Lithuanian)
  * `lv` (Latvian)
  * `ml` (Malayalam)
  * `mr` (Marathi)
  * `ms` (Malay)
  * `nb` (Norwegian)
  * `ne` (Nepali)
  * `nl` (Dutch)
  * `or` (Odia)
  * `pa` (Punjabi)
  * `pl` (Polish)
  * `pt` (Portuguese)
  * `ro` (Romanian)
  * `ru` (Russian)
  * `sa` (Sanskrit)
  * `sd` (Sindhi)
  * `si` (Sinhala)
  * `sm` (Samoan)
  * `sq` (Albanian)
  * `sv` (Swedish)
  * `sq` (Albanian)
  * `ta` (Tamil)
  * `te` (Telugu)
  * `th` (Thai)
  * `tl` (Tagalog)
  * `tr` (Turkish)
  * `uk` (Ukrainian)
  * `ur` (Urdu)
  * `uz` (Uzbek)
  * `vi` (Vietnamese)
  * `zh` (Chinese)
  * `zu` (Zulu)
</Accordion>

* Translation object

```typescript theme={null}
i18n={{
  // Make sure that the following is a proper language code,
  // since this is used by Intl.RelativeTimeFormat in order to calculate the relative time for each notification
  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
  lang: "de",

  translations: {
    poweredBy: "von",
    markAllAsRead: "Alles als gelesen markieren",
    notifications: "Benachrichtigungen",
    settings: "Einstellungen",
  },
}}

```

<Tip>Novu uses *`en`* as the default value for i18n</Tip>

### Customization using `styles` prop

`styles` prop can be used to cutomise styling of each component of notification center. Read more about [styles prop](/notification-center/client/react/api-reference#styles)

```javascript theme={null}
export const styles = {
  bellButton: {
    root: {
      marginTop: "20px",
      svg: {
        color: "#AFE1AF",
        fill: "white",
        minWidth: "20px",
        minHeight: "20px"
      }
    },
    dot: {
      rect: {
        fill: "white",
        strokeWidth: "0",
        width: "3px",
        height: "3px",
        x: 10,
        y: 2
      }
    }
  }
}
```

<Accordion title="Customizing styles">
  ```javascript theme={null}
  const primaryColor = "white";
  const secondaryColor = "#AFE1AF";
  const primaryTextColor = "#0C0404";
  const secondaryTextColor = "#494F55";
  const unreadBackGroundColor = "#869F9F";
  const primaryButtonBackGroundColor = unreadBackGroundColor;
  const secondaryButtonBackGroundColor = "#C6DFCD";
  const dropdownBorderStyle = "2px solid #AFE1AF";
  const tabLabelAfterStyle = "#AFE1AF !important";
  const ncWidth = "350px !important";

  export const styles = {
    bellButton: {
      root: {
        marginTop: "20px",
        svg: {
          color: secondaryColor,
          fill: primaryColor,
          minWidth: "20px",
          minHeight: "20px"
        }
      },
      dot: {
        rect: {
          fill: primaryColor,
          strokeWidth: "0",
          width: "3px",
          height: "3px",
          x: 10,
          y: 2
        }
      }
    },
    unseenBadge: {
      root: { color: primaryTextColor, background: secondaryColor }
    },
    popover: {
      root: { zIndex: -99 },
      arrow: {
        backgroundColor: primaryColor,
        borderLeftColor: secondaryColor,
        borderTopColor: secondaryColor
      },
      dropdown: {
        border: dropdownBorderStyle,
        borderRadius: "10px",
        marginTop: "25px",
        maxWidth: ncWidth
      }
    },
    header: {
      root: {
        backgroundColor: primaryColor,
        "&:hover": { backgroundColor: primaryColor },
        cursor: "pointer",
        color: primaryTextColor
      },
      cog: { opacity: 1 },
      markAsRead: {
        color: primaryTextColor,
        fontSize: "14px"
      },
      title: { color: primaryTextColor },
      backButton: {
        color: primaryTextColor
      }
    },
    layout: {
      root: {
        background: primaryColor,
        maxWidth: ncWidth
      }
    },
    loader: {
      root: {
        stroke: primaryTextColor
      }
    },
    accordion: {
      item: {
        backgroundColor: secondaryColor,
        ":hover": {
          backgroundColor: secondaryColor
        }
      },
      content: {
        backgroundColor: secondaryColor,
        borderBottomLeftRadius: "7px",
        borderBottomRightRadius: "7px"
      },
      control: {
        ":hover": {
          backgroundColor: secondaryColor
        },
        color: primaryTextColor,
        title: {
          color: primaryTextColor
        }
      },
      chevron: {
        color: primaryTextColor
      }
    },
    notifications: {
      root: {
        ".nc-notifications-list-item": {
          backgroundColor: secondaryColor
        }
      },
      listItem: {
        layout: {
          borderRadius: "7px",
          color: primaryTextColor,
          "div:has(> .mantine-Avatar-root)": {
            border: "none",
            width: "20px",
            height: "20px",
            minWidth: "20px"
          },
          ".mantine-Avatar-root": {
            width: "20px",
            height: "20px",
            minWidth: "20px"
          },
          ".mantine-Avatar-image": {
            width: "20px",
            height: "20px",
            minWidth: "20px"
          }
        },
        timestamp: { color: secondaryTextColor, fontWeight: "bold" },
        dotsButton: {
          path: {
            fill: primaryTextColor
          }
        },
        unread: {
          "::before": { background: unreadBackGroundColor }
        },
        buttons: {
          primary: {
            background: primaryButtonBackGroundColor,
            color: primaryTextColor,
            "&:hover": {
              background: primaryButtonBackGroundColor,
              color: secondaryTextColor
            }
          },
          secondary: {
            background: secondaryButtonBackGroundColor,
            color: secondaryTextColor,
            "&:hover": {
              background: secondaryButtonBackGroundColor,
              color: secondaryTextColor
            }
          }
        }
      }
    },
    actionsMenu: {
      item: { "&:hover": { backgroundColor: secondaryColor } },
      dropdown: {
        backgroundColor: primaryColor
      },
      arrow: {
        backgroundColor: primaryColor,
        borderTop: "0",
        borderLeft: "0"
      }
    },
    preferences: {
      item: {
        title: { color: primaryTextColor },
        divider: { borderTopColor: primaryColor },
        channels: { color: secondaryTextColor },
        content: {
          icon: { color: primaryTextColor },
          channelLabel: { color: primaryTextColor },
          success: { color: primaryTextColor }
        }
      }
    },
    tabs: {
      tabLabel: {
        "::after": { background: tabLabelAfterStyle },
        ":hover": { color: tabLabelAfterStyle },
        "[data-active]": { color: tabLabelAfterStyle }
      },
      tabsList: { borderBottomColor: primaryColor }
    }
  };
  ```
</Accordion>

[![Edit custom-styles-novu-nc](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/custom-styles-novu-nc-2jd46m?fontsize=14\&module=%2Fsrc%2Fstyles.js\&moduleview=1\&theme=dark)

## Customization Using Hooks

If you don't want to use our pre built component then, you can build your own notification center using hooks. `@novu/notification-center` react package provides many hooks like `useNotifications`, `useFetchNotifications`, `useUpdateUserPreferences`. Checkout all available [hooks](/notification-center/client/react/api-reference#hooks). All the hooks should be defined inside the [NovuProvider](/notification-center/client/react/api-reference#novuprovider) component. Most of the hooks are based on the `@tanstack/react-query` library.

Checkout below example on how to use `useNotifications` and `useFetchNotifications` hook
[![Edit useNotifications-useFetchNotifications-hook](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/usenotifications-usefetchnotifications-hook-2t6sgz?fontsize=14\&hidenavigation=1\&theme=dark)


# React Get Started
Source: https://v0.x-docs.novu.co/notification-center/client/react/get-started

Learn how to add novu powered In-App notification center to your React app

Novu provides the `@novu/notification-center` a React library that helps to add a fully functioning notification center to your web application in minutes. Let's do a quick recap on how you can easily use it in your application.

1. Install `@novu/notification-center` npm package in your react app

```jsx theme={null}
npm install @novu/notification-center
```

2. Add the below code in the app.tsx file

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
  IMessage,
} from "@novu/notification-center";

function Novu() {
  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <PopoverNotificationCenter colorScheme="dark">
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}
```

[![Edit kind-nova-xv6s9g](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark)

Go to this react app browser tab, there will be a bell icon. On clicking that bell icon, you will see a notification component popover

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Use your own backend and socket URL

By default, Novu's hosted services of API and socket are used. If you want, you can override them and configure your own.

```tsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
} from "@novu/notification-center";

function Novu() {
  return (
    <NovuProvider
      backendUrl={"YOUR_BACKEND_URL"}
      socketUrl={"YOUR_SOCKET_URL"}
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <PopoverNotificationCenter colorScheme="dark">
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}
```

## Notification center without bell

If you don't want to show the bell icon, you can directly render the notification center component without passing the bell, use `<NotificationCenter>` component in place of `<PopoverNotificationCenter>`

```jsx theme={null}
import {
  NovuProvider,
  NotificationCenter,
} from "@novu/notification-center";

<NovuProvider
  subscriberId={"SUBSCRIBER_ID"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
>
  <NotificationCenter colorScheme="dark" />
</NovuProvider>
```

## HMAC Encryption

When Novu's user adds the notification center to their application they are required to pass a `subscriberId` which identifies the user's end-customer, and the application Identifier which is acted as a public key to communicate with the notification feed API.

A malicious actor can access the user feed by accessing the API and passing another `subscriberId` using the public application identifier.

HMAC encryption will make sure that a `subscriberId` is encrypted using the secret API key, and those will prevent malicious actors from impersonating users.

### Enabling HMAC Encryption

In order to enable Hash-Based Message Authentication Codes, you need to visit the admin panel In-App settings page and enable HMAC encryption for your environment.

<Frame>
  <img />
</Frame>

1. Next step would be to generate an HMAC encrypted subscriberId on your backend:

```jsx theme={null}
import { createHmac } from "crypto";

const hmacHash = createHmac("sha256", process.env.NOVU_API_KEY)
  .update(subscriberId)
  .digest("hex");
```

2. Then pass the created HMAC to your client side application forward it to the component:

```jsx theme={null}
<NovuProvider
  subscriberId={"SUBSCRIBER_ID_PLAIN_VALUE"}
  subscriberHash={"SUBSCRIBER_ID_HASH_VALUE"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
>
  <NotificationCenter colorScheme="dark" />
</NovuProvider>
```

<Info>If HMAC encryption is active in In-App provider settings and  `subscriberHash` along with `subscriberId` is not provided, then notification center will not load</Info>

## Notification Actions

### onNotificationClick

This function is invoked when the user clicks anywhere on the notification except for CTA actions.

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
  IMessage,
} from "@novu/notification-center";

function Novu() {
  function handleOnNotificationClick(message: IMessage) {
    // your logic to handle the notification click
    if (message?.cta?.data?.url) {
      window.location.href = message.cta.data.url;
    }
  }

  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <PopoverNotificationCenter
        colorScheme="dark"
        onNotificationClick={handleOnNotificationClick}
      >
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}
```

### onActionClick

This function is invoked when the user clicks on the action CTA buttons of the notification

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  IMessage,
  MessageActionStatusEnum,
  useUpdateAction,
  ButtonTypeEnum,
  NotificationBell,
} from "@novu/notification-center";

export default function Novu() {

  const CustomNotificationCenter = () => {
    const { updateAction } = useUpdateAction();

    const handleOnActionClick = async (
      templateIdentifier: string,
      btnType: ButtonTypeEnum,
      notification: IMessage
    ) => {
      if (templateIdentifier === "friend-request") {
        if (btnType === "primary") {
          /** Call your API to accept the friend request here **/

          /** And then update Novu that this action has been taken, so the user won't see the button again **/
          updateAction({
            messageId: notification._id,
            actionButtonType: btnType,
            status: MessageActionStatusEnum.DONE,
          });
        }
      }
    };

    return (
      <PopoverNotificationCenter
        colorScheme={"dark"}
        onActionClick={handleOnActionClick}
      >
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    );
  };

  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <CustomNotificationCenter />
    </NovuProvider>
  );
}
```

<Note>CTA buttons text and redirect url field supports dynamic variables</Note>

## Avatar Icons

Avatar images can be shown with in-app notifications. To do so, enable `Add an Avatar` option in in-app step editor as shown below

<Frame>
  <img />
</Frame>

**There are 3 ways to show the avatar images in the notifications:**

<Frame>
  <img />
</Frame>

### User Avatar

This option will show the avatar of the actor user. actor field can be sent while triggering the worklfow. Each subscriber has `avatar` field. For this option to work actor should have `avatar` field set with valid publicly accessible image URL. If the actor doesn't have `avatar` field, then the default avatar will be shown. Worklfow trigger example with avatar

```javascript theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: 'subscriberId_1',
  },
  payload: {
    "key": "value"
  },
  actor: "subscriberId_2"
});
```

Here subscriberId\_2 is used as actor and workflow is triggered to subscriberId\_1

### Static Avatar Url

This option can be used if you want to show same, static and custom avatar icon for each in-app notification of this workflow in-app step. Make sure to toggle off **User Avatar** option to enable this. This is a input field where only valid publicly accessible image URL can be entered. Currently variables are not supported in this field.

### System Avatar Icons

Novu supports 6 system avatar icons. These are default icons that can be selected as avatar icon. Once selected, same icon will be used as avatar icons for all notifications of this in-app step.

## Realtime sockets

Novu provides a real-time socket API for you to consume and get updates about new notifications added to the user's feed. To use the socket connection you can use the `useSocket` hook provided by the `@novu/notification-center` library. Let's see an example of that:

```tsx theme={null}
import { NovuProvider, useSocket } from "@novu/notification-center";

function Novu() {
  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <CustomNotificationCenter />
    </NovuProvider>
  );
}

function CustomNotificationCenter() {
  const { socket } = useSocket();

  useEffect(() => {
    if (socket) {
      socket.on("notification_received", (data) => {
        console.log(data);
      });
    }

    return () => {
      if (socket) {
        socket.off("notification_received");
      }
    };
  }, [socket]);

  return <></>;
}
```

There are three sockets events available:

1. `unseen_count_changed`
2. `unread_count_changed`
3. `notification_received`

### Toast notification

Novu does not have a native toast component. However, if your project is using any UI library like chakra, material-ui, mantine then toast component (snackbar in case of material-ui) of these libraries can be used with `useSocket` hook. Add the toast opening code in `socket.on` callback.

```javascript toast.tsx theme={null}
socket.on("notification_received", (data) => {
  console.log(data);
  // set received notification content as toast content
  setToastContent(data.content)
  // open the toast
  openToast(true)
});
```

## Example

[![Edit kind-nova-xv6s9g](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark)

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="The notification center is not loading properly.">
    Possible reasons for the notification center not loading properly:

    * Invalid subscriberId
    * Invalid applicationIdentifier
    * Invalid subscriberHash (in case of active HMAC encryption)
    * Invalid backendUrl (in case of self-hosted)
    * Invalid socketUrl (in case of self-hosted)
  </Accordion>

  <Accordion title="There is a render error due to the notification center in React.">
    The notification center should be wrapped in `<NovuProvider>`
  </Accordion>

  <Accordion title="What is the difference between a redirect URL and CTA?">
    The redirect URL is for the entire notification item, When the user clicks the notification, the user will be routed to that url. CTA are two call-to-action buttons. `onNotificationClick` function prop is used for redirecting url and the `onActionClick` function prop is used for CTA.
  </Accordion>

  <Accordion title="Can bell icon in Novu dashboard be used for in-app channel testing?">
    Bell icon and notification center in Novu dashboard is only for receiving system related notifications like user you invited has joined, password reset request sent. It can not to used to test notification center. Consider using our [codesandbox example](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark) instead.
  </Accordion>

  <Accordion title="How to fix CORS error with notification center?">
    Our notification center is configures for all hosts. Please disable root level `withCredentials` config in axios or fetch http requests.
  </Accordion>
</AccordionGroup>


# Configuring Multiple Tabs
Source: https://v0.x-docs.novu.co/notification-center/client/react/multiple-tabs



Novu allows to create a multi-tab experience for a notification center, in a way you can fetch the notifications feed using a filtered query.

### Defining stores

To create multiple stores you can use the prop `stores` on the `NovuProvider` component. Each store has `storeId` property that will be used to interact with information related to this store.

```tsx theme={null}
<NovuProvider
  stores={[
    /**
	storeId and feedIdentifier must be identical and should be copied from In-App editor feed
  */
    {
      storeId: "product-updates",
      query: { feedIdentifier: "product-updates" },
    },
    { storeId: "user-activity", query: { feedIdentifier: "user-activity" } },
  ]}
  subscriberId={"SUBSCRIBER_ID"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
>
  <PopoverWrapper />
</NovuProvider>
```

Using the `query` object multiple fields can be passed for feed API:

* `feedIdentifier` - Can be configured and created on the WEB UI
* `seen` - Identifies if the notification has been seen or not

After specifying the `stores` prop, you can use the `storeId` property to interact with the store.

### Managing feeds on the web UI

1. How to add a new feed or select existing feed for In-App step?

To add a new feed, enable *Use Feeds* checkbox in In-App editor. Select from existing feeds or create a new feed by writing in the input field and then clicking on plus icon in the right side.

<Frame>
  <img />
</Frame>

2. How to copy `feedIdentifier` (`storeId`)

To copy `feedIdentifier` (`storeId`) click on the feed name of existing feeds. copy three dot icon. a menu will appear. click on Copy ID option to copy selected feed's `feedIdentifier`

<Frame>
  <img />
</Frame>

<Info>
  By specifying only a storeId, without a query, you could get all notifications.
</Info>

### Using `tabs` prop on the notification center

```tsx theme={null}
<PopoverNotificationCenter
  colorScheme="dark"
  tabs={[
    // name can be any custom name
    { name: "Product Updates", storeId: "product-updates" },
    { name: "User Activity", storeId: "user-activity" },
  ]}
  colorScheme={colorScheme}
  onNotificationClick={handlerOnNotificationClick}
  onActionClick={handlerOnActionClick}
>
  {({ unseenCount }) => {
    return (
      <NotificationBell colorScheme={colorScheme} unseenCount={unseenCount} />
    );
  }}
</PopoverNotificationCenter>
```

<Frame>
  <img />
</Frame>

## Example

[![Edit tabs-in-in\_app](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/tabs-in-in-app-xdk74x?fontsize=14\&hidenavigation=1\&theme=dark)

## Important Links

<CardGroup>
  <Card title="Get all feeds" icon="plug" href="/api-reference/feeds/get-feeds" />

  <Card title="Create a new feed" icon="plug" href="/api-reference/feeds/create-feed" />

  <Card title="Delete a feed" icon="plug" href="/api-reference/feeds/delete-feed" />
</CardGroup>


# Subscriber Preference
Source: https://v0.x-docs.novu.co/notification-center/client/react/preference



By default, Novu will show the subscriber preferences cog icon on the notification center component. If you want to hide it, you can use the prop `showUserPreferences` on the `PopoverNotificationCenter` component.

Users can enable/disable any active channel in the workflow using subscriber preferences

<img />

## Get subscriber preferences

<CodeGroup>
  ```typescript Node.JS theme={null}
  import { Novu } from "@novu/node";

  const novu = new Novu("<NOVU_API_KEY>");

  // 111 is subscriberId
  await novu.subscribers.getPreference("111");
  ```
</CodeGroup>

## Update subscriber preference for a workflow

<CodeGroup>
  ```typescript Node.JS theme={null}
  import { Novu, ChannelTypeEnum } from "@novu/node";

  const novu = new Novu("<NOVU_API_KEY>");

  // enable in_app channel
  await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
    enabled: true,
    channel: { type: ChannelTypeEnum.IN_APP, enabled: true },
  });

  // enable email channel
  await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
    enabled: true,
    channel: { type: ChannelTypeEnum.EMAIL, enabled: true },
  });
  ```
</CodeGroup>

Read more about [subscriber preference](/subscribers/preferences).


# Vue Component
Source: https://v0.x-docs.novu.co/notification-center/client/vue



The `@novu/notification-center-vue` package provides a Vue component wrapper over the Notification Center Web Component that you can use to integrate the notification center into your Vue application.

## Installation

```bash theme={null}
npm install @novu/notification-center-vue
```

<Info>Novu supports only Vue 3.</Info>

## The plugin

The Notification Center Vue plugin can be used to register the `NotificationCenterComponent` as a global component. This is the recommended way to use the component.

```typescript theme={null}
import { createApp } from "vue";
import NotificationCenterPlugin from "@novu/notification-center-vue";
import "@novu/notification-center-vue/dist/style.css";
// your app component
import App from "./App.vue";

createApp(App).use(NotificationCenterPlugin).mount("#app");
```

## Example usage

```html theme={null}
<script lang="ts">
  export default {
    data() {
      return {
        applicationIdentifier: import.meta.env.VITE_NOVU_APPLICATION_IDENTIFIER,
        subscriberId: import.meta.env.VITE_NOVU_SUBSCRIBER_ID,
      };
    },
    methods: {
      sessionLoaded() {
        console.log("Notification Center Session Loaded!");
      },
    },
  };
</script>

<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
  />
</template>
```

By default, the `NotificationCenterComponent` renders the default bell button that opens the notification center when clicked, but it can be customized.

## Custom Bell Button

You can pass the custom bell button component as the default slot to the `NotificationCenterComponent` and it will be used to open the notification center. The `NotificationCenterComponent` also accepts a scoped slot which exposes the `unseenCount` property - the number of unseen notifications counts.

```tsx theme={null}
<script lang="ts">
  export default {
    data() {
      return {
        applicationIdentifier: import.meta.env.VITE_NOVU_APPLICATION_IDENTIFIER,
        subscriberId: import.meta.env.VITE_NOVU_SUBSCRIBER_ID,
      };
    },
    methods: {
      sessionLoaded() {
        console.log('Notification Center Session Loaded!');
      },
    },
  };
</script>

<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>
```

## Example

* [Vue Notification Center Example](https://github.com/novuhq/examples/tree/main/vue-notification-center-example)
* [CodeSandBox Link 🔗](https://codesandbox.io/p/sandbox/novu-vue-in-app-88p8vx)

## Props

The `NotificationCenterComponent` accepts the same set of props as the [Web Component](./web-component#properties).

It also accepts an extra prop

| Prop     | Type      | Description                                                                                                                                          |
| -------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| triggers | string\[] | This is an Array of events that controls the underlying popper component's trigger. [Read more here](https://floating-vue.starpad.dev/api/#triggers) |


# Web Component
Source: https://v0.x-docs.novu.co/notification-center/client/web-component



The Notification Center Web Component is a custom element that can be used in any web application. It is built by wrapping the React components and consists from its core the three pieces:  `NovuProvider`,  `PopoverNotificationCenter`, and  `NotificationBell` combined together into one.

## ESM module[](https://docs.novu.co/notification-center/web-component#esm-module)

Make sure that you have installed the `@novu/notification-center` package:

```bash theme={null}
npm install @novu/notification-center
```

Then, import the web component and register it as a custom element:

```tsx theme={null}
import { NotificationCenterWebComponent } from "@novu/notification-center";

customElements.define(
  "notification-center-component",
  NotificationCenterWebComponent
);
```

After that, you can use the web component in your HTML:

```html theme={null}
<!-- HTML -->
<notification-center-component
  style="display: inline-flex"
  application-identifier="APPLICATION_IDENTIFIER"
  subscriber-id="SUBSCRIBER_ID"
></notification-center-component>
<script>
  // here you can attach any callbacks, interact with the Notification Center Web Component API
  let nc = document.getElementsByTagName("notification-center-component")[0];
  nc.onLoad = () => console.log("Notification Center session loaded!");
</script>
```

**Please note:** that the properties are named with a `kebab-case` in the HTML, but depending on the technology you use it might be a `camelCase`, for ex. Vue/Angular props are bound with variables using that convention.

### Example

[CodeSandBox Link 🔗](https://codesandbox.io/s/novu-web-component-esm-rltcr5)

## Bundled version (preview)

Sometimes you might not be able to use the ESM module, for example in the WordPress environment. In that case, you can use the bundled version of the Notification Center Web Component that is available on the CDN.

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    ...
    <script src="​https://web-component.novu.co/index.js"></script>
  </head>
  <body>
    <notification-center-component
      style="display: inline-flex"
      application-identifier="APPLICATION_IDENTIFIER"
      subscriber-id="SUBSCRIBER_ID"
    ></notification-center-component>
    <script>
      // here you can attach any callbacks, interact with the web component API
      let nc = document.getElementsByTagName(
        "notification-center-component"
      )[0];
      nc.onLoad = () => console.log("hello world!");
    </script>
  </body>
</html>
```

### Example

[CodeSandBox Link 🔗](https://codesandbox.io/s/novu-web-component-bundled-rgrj5r?file=/index.html)

## Properties

The Notification Center Web Component has a few properties that you can use to customize the behavior of the component. The only required property is `applicationIdentifier`.

If you are using TypeScript, then you might want to check the `NotificationCenterComponentProps` interface.

| Prop                       | Type                                                                                         | Description                                                                                                                                                                                                                                                                                                  |
| -------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| backendUrl                 | string                                                                                       | Custom API location in case of self-hosted version of Novu.                                                                                                                                                                                                                                                  |
| socketUrl                  | string                                                                                       | Custom WebSocket Service location in case of self-hosted version of Novu.                                                                                                                                                                                                                                    |
| subscriberId               | string                                                                                       | The subscriberId is a custom identifier used when identifying your users within the Novu platform.                                                                                                                                                                                                           |
| applicationIdentifier      | string                                                                                       | Is a public identifier used to identify your application, can be found in the Novu Admin panel.                                                                                                                                                                                                              |
| subscriberHash             | string                                                                                       | The hashed subscriber id. [Read more about hmac encryption](/notification-center/client/react/get-started#hmac-encryption).                                                                                                                                                                                  |
| stores                     | object\[]                                                                                    | The array of the store items that are bound with the feed, it's used together with tabs property if you would like to have separate feeds in the notification center. [Read more here](/notification-center/client/react/multiple-tabs)                                                                      |
|                            |                                                                                              |                                                                                                                                                                                                                                                                                                              |
| tabs                       | object\[]                                                                                    | The array of items that do describe the tabs/feeds, they are bound with the stores property. [Read more here](/notification-center/client/react/multiple-tabs).                                                                                                                                              |
| showUserPreferences        | boolean                                                                                      | The flag indicating whether the user preference settings should be visible or not.                                                                                                                                                                                                                           |
| allowedNotificationActions | boolean                                                                                      | The flag indicating whether to show/hide the dots menu for actions performed on a notification.                                                                                                                                                                                                              |
| popoverConfig              | object                                                                                       | The object defining how the popover should be positioned. It's properties are position and offset.                                                                                                                                                                                                           |
| popover                    | object                                                                                       | The object defining how the popover should be positioned. It's properties are position and offset. popover is deprecated, use popoverConfig instead.                                                                                                                                                         |
| theme                      | [INovuTheme](/notification-center/client/react/api-reference#the-theme-interface)            | The object defining the the light/dark styles of the Notification Center component. We discourage you to use this prop to do the styling, instead it's recommended to use the styles property.                                                                                                               |
| styles                     | [NotificationCenterStyles](/notification-center/client/react/api-reference#styles-interface) | The object allows you to define the custom CSS code.                                                                                                                                                                                                                                                         |
| colorScheme                | string                                                                                       | The prop defines which color version of the styles the component should set. The options are light and dark.                                                                                                                                                                                                 |
| i18n                       | object                                                                                       | The object allowing to [customize the UI language](/notification-center/client/react/customization#customize-the-ui-language).                                                                                                                                                                               |
| onLoad                     | function                                                                                     | The callback function that is called when the session is successfully initiated. It receives the first argument object with the organization property. There is a sibling property sessionLoaded that might be used in environments that do not allow to use properties with the prefix on, like in Angular. |
| onNotificationClick        | function                                                                                     | The callback function that is called when the user has clicked on the notification. The first argument it receives is the notification object. There is a sibling property notificationClicked.                                                                                                              |
| onUnseenCountChanged       | function                                                                                     | The callback function that is called when the unseen notifications count changes. The first argument it receives is the number of unseen notifications count. There is a sibling property unseenCountChanged.                                                                                                |
| onActionClick              | function                                                                                     | The callback function that is called when user clicks on one of the notification buttons (primary/secondary). The arguments it receives are: template identifier, button type, and notification object. There is a sibling property actionClicked.                                                           |
| onTabClick                 | function                                                                                     | The callback function that is called when user clicks on the feed tab. The first arguments it receives is the tab object. There is a sibling property tabClicked.                                                                                                                                            |

## Limitations

It's important to note that there are some limitations when using the Web Component compared to the React version:

* You get an all-in-one component
* It doesn't support the `children, header, footer, emptyState, listItem` props
* It's a wrapped react component, which means a bigger bundle size (we are working on it to make it smaller)


# Introduction to Notification Center
Source: https://v0.x-docs.novu.co/notification-center/introduction

Learn more about Novu's Notification Center.

The notification center is a component, also sometimes referred to as a widget that furnishes your web application with a beautiful and smooth In-App notification experience for users.

In-App notifications are different from push notifications in the sense that In-App notifications are consumed by the user in your app itself, whether push notifications are shown on the device level. Read more about [push channel and supported providers.](/channels-and-providers/push/overview)

Novu provides a pre-built, ready-to-use, and customizable UI component. It also allows you to bring your own UI via a headless component which can be used to add In-App notifications to any platform.

<iframe />

## Example

[![Edit kind-nova-xv6s9g](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark)

## Why use the Novu notification center?

* Users can manage subscriber preferences from the notification center itself.
* You want to notify about any product activity related to the user.
* Prebuilt UI component so no need to build UI from scratch.
* Highly customizable as per your product design system.
* Multi-device real-time notification experience powered by web sockets.
* Secure your connection using HMAC encryption.
* Have multi-tabs notification experience.

## Concepts

1. `In-App notification`:- In-App notification is a message sent to the subscriber using an In-App channel step in the workflow.
2. `In-App notifications feed`:- List of all In-App messages sent to a particular subscriber.
3. `feeds`:- feeds are stores/tabs in which In-App messages can be grouped. One message can be in only one feed.
4. `notification actions`:- Notification actions are cta buttons below notification content that can be clicked to perform any action or external API call.
5. `redirect url`:- When a single notification item from the list is clicked then it can be configured to perform an action or redirect to any URL.

## UI Libraries

1. [React](/notification-center/client/react/get-started)
2. [Vue](/notification-center/client/vue)
3. [Angular](/notification-center/client/angular)
4. [Web Component](/notification-center/client/web-component)
5. [Headless](/notification-center/client/headless/get-started)

## Backend SDK Methods

[Backend sdk methods](/notification-center/backend/methods)


# Environments
Source: https://v0.x-docs.novu.co/platform/environments

Learn about environments in Novu

Novu runs all your requests in the context of an environment. By default, Novu creates two environments when your account was just created, `development` and `production`.

## Development environment

The development environment is used for testing purposes and validating notification changes prior to committing them to the production environment.

## Production environment

It will be your live/production environment, you cannot make changes to this environment directly. You will first have to make the changes in the `development` environment and then promote it to `production`. This is a read-only environment.

## Data associated with environments

Novu will separate most of the data associated with your account based on the current accessed environment. This will include:

* Subscribers
* Workflows
* Messages
* Execution logs
* Connected integrations
* Notification feeds
* Brand related assets and settings

Each environment will be accessed using a separate credential set:

* **Application Identifier** - This is a public identifier used in client-side applications to identify your application. It is unique to an environment in an organization and is different from `Provider Identifier`.
* **Provider Identifier** - This is an identifier for a provider in a channel. For example, say you're using email notifications. Here, two different providers will have two different `Provider Identifier`. Even if you're using two different integration of the same provider, you'll have two different `Provider Identifier`, each unique to one integration. For example, if you've two slack integrations, they will have two different `Provider Identifier`.
* **API Secret Key** - A secret key used when communicating with the `Novu API` from your backend services.

We suggest configuring these key sets based on your active environment, the same as you would use to manage different service credentials and serve them based on the current environment in which your code is deployed.

## Promoting pending changes to production

After making a change to a workflow or brand relating settings, this change will be added under the [changes](https://web.novu.co/changes?utm_campaign=docs-environments) page in the admin panel.

A change is generated by making a difference between the `development` environment and the target `production` environment. All pending changes will be listed on the [changes](https://web.novu.co/changes?utm_campaign=docs-environments) page.

A change can either be applied manually or by pressing the **Promote all changes** button.

<Frame>
  <img />
</Frame>

<br />

<Note> Before pushing a change to production, make sure that the code associated with this change was pushed to production. This is specifically important when adding new variables to a workflow. </Note>

## API Reference Links

* [Get Current Environment API](/api-reference/environments/get-current-environment/)
* [Get API Keys API](/api-reference/environments/get-api-keys/)
* [Regenerate API Keys API](/api-reference/environments/regenerate-api-keys/)


# Inbound Parse Webhook
Source: https://v0.x-docs.novu.co/platform/inbound-parse-webhook

Learn how to process incoming emails for a domain or subdomain

Inbound Webhook is a feature that allows processing of incoming emails for a domain or subdomain.
The feature parses contents of an email and POSTs the information to a specified URL in a `multipart/form-data` format.

<Note>
  This feature is available only in Novu cloud. This feature will not work in community self
  hosted version and local environment.
</Note>

## Steps to set up Inbound Webhook

1. Set up an MX Record:
   * Log in to your domain host's website and navigate to the MX Records page.
   * Create a new MX record for the subdomain you want to process incoming email (e.g. reply.yourdomain.com).
   <Warning>
     You must create a new record for this as this feature does not work if the MX record is already set on the domain.
     Here is an example with [route 53](https://medium.com/@deep_blue_day/how-to-create-a-subdomain-in-amazon-route-53-81918654f5bf)
   </Warning>
   * Assign the MX record a priority of 10 and point it to the specified inbound mail server that located on the admin dashboard on the Email Settings.
     <Info>
       For US, use `inbound-mail.novu.co` and For EU, use
       `eu.inbound-mail.novu.co`
     </Info>
2. Add Domain to allowed list:
   * Log in to the dashboard.
   * Go to the Setting tab in the left vertical navbar.
   * Navigate to Email Settings on the settings page.
   * Add your domain to the allowed domain box.
   <Warning>
     You can only add one Inbound Webhook domain per organization.
   </Warning>
3. Enable Inbound Parse and Set Webhook URL:
   * Log in to the dashboard.
   * Navigate to the Workflow Editor.
   * Select the email step.
   * Enable the Inbound Parse feature.
   * Set the Webhook URL to the location where you want the parsed data to be POSTed.

<Note>The Webhook URL must be publicly accessible without authentication.</Note>


# Webhooks for Providers
Source: https://v0.x-docs.novu.co/platform/webhooks-for-providers

Learn how to setup webhook support for a provider.

Novu provides a URL that you can use to setup webhook support for your integrated provider.

This enables to receive much more detailed information from the provider about the outgoing messages in the [Activity Feed](/activity-feed/introduction) section.

Currently, only `Email` and `SMS` channels are supported with limited providers. Support for more providers will be added in future.

<Note>
  This feature is available only in Novu cloud. This feature will not work in community self
  hosted version and local environment.
</Note>

## Get your Webhook URL

To get your provider specific webhook URL, follow the below steps:

* Open your already connected provider from the `Integration Store` page.
* Scroll down the modal to find the `Webhook URL` field.
* Copy the given URL to configure it on the provider's webhook setup page.

<Frame>
  <img />
</Frame>

<br />

<Note> Webhook URL will only be visible for connected providers and after you've connected the provider. </Note>

## Supported Providers

* [Mailjet](/channels-and-providers/email/mailjet)
* [Mandrill](/channels-and-providers/email/mandrill)
* [Postmark](/channels-and-providers/email/postmark)
* [Sendgrid](/channels-and-providers/email/sendgrid)
* [Sendinblue](/channels-and-providers/email/sendinblue)
* [Telnyx](/channels-and-providers/sms/telnyx)
* [Twilio](/channels-and-providers/sms/twilio)


# .NET
Source: https://v0.x-docs.novu.co/quickstarts/.NET

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with .NET.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications from a .NET app.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-dotnet) if you don’t have one yet.
* A working .NET development environment with a .NET version of .NET Core 2.0+ and .NET Framework of 4.6.1+.

You can also [view the completed code](https://github.com/novuhq/novu-dotnet-quickstart) of this quick start in a GitHub repo.

## Install Novu .NET SDK

The [.NET SDK](https://github.com/novuhq/novu-dotnet) provides a fluent and expressive interface for interacting with Novu's API and managing notifications.

Now install the Novu .NET SDK by running the following command in your terminal:

```bash theme={null}
dotnet add package Novu

```

Otherwise, modify your .csproj file add the following to it:

```xml theme={null}
<ItemGroup>
    <PackageReference Include="Novu" Version="*" />
</ItemGroup>

```

Next, install the SDK by running the following `dotnet` command:

```bash theme={null}
dotnet restore

```

## Initialize & Configure the Novu SDK

Create a new file, `Program.cs` in your application and add the following code to it:

Program.cs:

```csharp theme={null}
using Novu.DTO;
using Novu.DTO.Topics;
using Novu.Models;
using Novu;

 var novuConfiguration = new NovuClientConfiguration
{
    ApiKey = "<NOVU_API_KEY>",
};

var novu = new NovuClient(novuConfiguration);
```

Replace the `ApiKey`’s value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-dotnet) and be sure to use your specific Novu instance URL.

<Note>
  Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-dotnet) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favourite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create A Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **Untitled.** Rename it to a more suitable title.
4. Select **Email** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

6. Click on the “Test” tab and send a test email to verify your workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. Yaaay, you have successfully sent your first notification via the Novu dashboard! Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click “Subscribers” on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```csharp theme={null}
// Create subscriber

var newSubscriberDto = new SubscriberCreateData
{
  SubscriberId = "77809", //replace with system_internal_user_id
  FirstName = "John",
  LastName = "Doe",
  Email = "benlin1994@gmail.com",
  Data = new List<AdditionalDataDto>{
    new AdditionalDataDto
    {
        Key = "External ID",
        Value = "1122334455"
    },
    new AdditionalDataDto
    {
        Key = "Job Title",
        Value = "Software Engineer"
    }
  }
};

var subscriber = await novu.Subscriber.Create(newSubscriberDto);
```

Run the code in your terminal like so:

```bash theme={null}
dotnet run Program.cs

```

You should see the subscriber on your Novu dashboard.

<Frame>
  <img />
</Frame>

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `UpdateSubscriber` method like so:

Program.cs:

```csharp theme={null}
// Update subscriber detail
var subscriber7789 = await novu.Subscriber.GetSubscriber("7789");

subscriber7789.Email = "validemail@gmail.com"; // replace with valid email
subscriber7789.FirstName = "<insert-firstname>"; // optional
subscriber7789.LastName = "<insert-lastname>"; // optional

var updatedSubscriber = await novu.Subscriber.Update("7789",subscriber7789);
```

Other valid fields that can be updated are `phone`, `avatar`, and `data` . The `data` field can accept an array of metadata that you want to attach to the subscriber.

<Note>
  To make all of your app users subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

OnboardEventPayload.cs:

```csharp theme={null}
// OnboardEventPayload.cs
public class OnboardEventPayload
{
  [JsonProperty("username")]
  public string Username { get; set; }

  [JsonProperty("welcomeMessage")]
  public string WelcomeMessage { get; set; }
}

```

Program.cs:

```csharp theme={null}
var onboardingMessage = new OnboardEventPayload
{
  Username = "jdoe",
  WelcomeMessage = "Welcome to novu-dotnet"
};

var payload = new EventCreateData()
{
  EventName = "onboarding", //make sure you have a trigger named "onboarding"
  To = { SubscriberId = "7789" },
  Payload = onboardingMessage
};

var trigger = await novu.Event.Trigger(payload);

if (trigger.Data.Acknowledged)
{
  Console.WriteLine("Trigger has been created.");
}

```

Before running the code, make sure you understand the following:

* The value of `EventName` should be the workflow’s trigger ID/slug(it's the value all in small caps).

<Frame>
  <img />
</Frame>

* The value of `Payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `SubscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriberId.

Run the code to trigger a notification!

```bash theme={null}
dotnet run Program.cs

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safeguards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```csharp theme={null}
// Create Topic
var topicRequest = new TopicCreateData
{
    Key = "frontend-users",
    Name = "All frontend users",

};

var topic = await novu.Topic.Create(topicRequest);
```

Before running the code, make sure you understand the following:

* When creating a `Key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `Name` should be a descriptive topic name.

## Add Subscribers to a Topic

Copy and paste the following code into your app to add subscribers to a topic:

```csharp theme={null}

// Add Subscriber to Topic
var topicKey = "frontend-users";
var subscriberList = new TopicSubscriberUpdateDto
{
    Keys = new List<string>
    {
        "7789",
        "7790",
    }
};

//Or

var subscriberList = new TopicSubscriberCreateData(new List<string>
{
    "7789",
    "7790"
});

var result = await novu.Topic.AddSubscriber(topicKey, subscriberList);
```

## Sending a Notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

Program.cs

```csharp theme={null}
// Send notifications to a topic (all frontend users)

var onboardingMessage = new OnboardEventPayload
{
  WelcomeMessage = "Welcome to novu-dotnet"
};

var payloadTopic = new EventTopicTriggerDto
{
  EventName = "onboarding",
  Payload = onboardingMessage,
  Topic = { Type = "7789", TopicKey = "frontend-users" },

};

var triggerTopic = await novu.Event.TriggerTopicAsync(payloadTopic);

if (triggerTopic.TriggerResponsePayloadDto.Acknowledged);
{
  Console.WriteLine("Trigger has been created.");
}

```

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider and triggered a notification in your application.


# Angular
Source: https://v0.x-docs.novu.co/quickstarts/angular

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Angular.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications and integrate a rich, customizable and ready-to-use real-time UI In-App notification center in Angular apps.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-angluar) if you don’t have one yet
* Angular CLI (Command Line Interface) installed on your machine
* Angular version 15 or higher

You can also [view the completed code](https://github.com/novuhq/angular-quickstart) of this quick start in a GitHub repo.

## Create a new Angular app

To create a new Angular app, open a terminal or command prompt and  run the following command:

```bash theme={null}
ng new my-app
```

Here, `my-app` is the name of your new Angular app.  This command will create a new Angular app with a basic file structure and all the necessary dependencies installed.

Navigate to the app directory by running the following command:

```bash theme={null}
cd my-app
```

Once you are in the app directory, you can start the development server by running the following command:

```bash theme={null}
ng serve
```

This command will start the development server and launch your app in the default browser. You can access your app by navigating to `http://localhost:4200/`.

<Frame>
  <img />
</Frame>

## Install Novu Angular Notification Center Package

The Novu Angular package provides a Angular component wrapper over the web component that you can use to integrate the notification center into your Angular application.

Navigate to the root directory of your Angular application. Now install the Angular Notification Center package by running the following command in your terminal:

<CodeGroup>
  ```bash pnpm theme={null}
  pnpm i @novu/notification-center-angular
  ```

  ```bash npm theme={null}
  npm i @novu/notification-center-angular
  ```

  ```bash yarn theme={null}
  yarn add @novu/notification-center-angular
  ```
</CodeGroup>

## Configuring Application Environments

Using the Angular CLI, start by running the [generate environments command](https://angular.io/cli/generate#environments-command)
shown here to create the `src/environments/`directory and configure the  project to use these files.

```bash theme={null}
ng generate environments
```

Navigate to `my-app/src/environments/environment.ts`  and add the following variables: `subscriberId`, `applicationIdentifier`

* **`applicationIdentifier`** can be found here: [https://web.novu.co/settings](https://web.novu.co/settings)
* **`subscriberId`** can be found here: [https://web.novu.co/subscribers](https://web.novu.co/subscribers)

```tsx theme={null}
export const environment = {
  production: false,
  subscriberId: '',
  applicationIdentifier: '',
};
```

Copy and paste the same code into `my-app/src/environments/environment.development.ts`

These variables are needed for the `GET` request our notification center will make to Novu’s API to push notifications into the feed.

## Adding Novu Module

Now, navigate to the `app.module.ts` file `(my-app/src/app/app.module.ts)`

* Import `CUSTOM_ELEMENTS_SCHEMA` from `'@angular/core'`
* Add Novu’s notification center module

```jsx theme={null}
import { CUSTOM_ELEMENTS_SCHEMA, NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { AppComponent } from './app.component';
import { NotificationCenterModule } from '@novu/notification-center-angular';

@NgModule({
  declarations: [AppComponent],
  imports: [BrowserModule, NotificationCenterModule],
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
  providers: [],
  bootstrap: [AppComponent],
})
export class AppModule {}
```

Head to `my-app/src/app/app.component.ts` file.

⚠️ The `app.component.ts` file is a critical part of an Angular application, as it  defines the root component and provides the foundation for the rest of  the app's functionality.

Now, we are going to import the `environment` variables to make them accessible in the `app.component.html` and the `styles` properties of our notification center

(there are many properties, but you can discover them later on)

```tsx theme={null}
import { Component } from '@angular/core';
import { environment } from '../environments/environment';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css'],
})
export class AppComponent {
  title = 'my-app';

  subscriberId = environment.subscriberId;
  applicationIdentifier = environment.applicationIdentifier;

  styles = {
    bellButton: {
      root: {
        svg: {
          color: 'white',
          width: '45px',
          height: '40px',
          fill: 'white',
        },
      },
      dot: {
        rect: {
          fill: 'rgb(221, 0, 49)',
          strokeWidth: '0.2',
          stroke: 'white',
          width: '3.5px',
          height: '3.5px',
        },
        left: '40%',
      },
    },
    header: {
      root: {
        backgroundColor: '',
        '&:hover': { backgroundColor: '' },
        '.some_class': { color: '' },
      },
    },
    layout: {
      root: {
        backgroundColor: '',
      },
    },
    popover: {
      arrow: {
        backgroundColor: '',
        border: '',
      },
    },
  };

  sessionLoaded = (data: unknown) => {
    console.log('loaded', { data });
  };
}
```

The Angular component is generated as a wrapper around the original React component. This approach is clever, as it allows Novu's engineers to focus on creating and developing things in the React way.

Additionally, many other frameworks can still use the created components using the wrapping approach.

Now head to the `my-app/tsconfig.json` file, we’re going to add `"allowSyntheticDefaultImports": true` to the `compilerOptions` array.

```diff theme={null}
{
  "compilerOptions": {
+   "allowSyntheticDefaultImports": true,
  }
}
```

## Use & Display The Notification Center Component

Open the `my-app/src/app/app.component.html` file.

This file contain the CSS code along with the HTML one - ideally you should separate the CSS to the `my-app/src/app/app.component.css` file, but it’s not mandatory.

We will add our notification center to the .toolbar div.

Paste the following into your `app.component.html` file:

```jsx theme={null}
  <div id="bell-icon">
    <notification-center-component
      [subscriberId]="subscriberId"
      [applicationIdentifier]="applicationIdentifier"
      [sessionLoaded]="sessionLoaded"
      [styles]="styles"
    ></notification-center-component>
  </div>
```

And in the `<style>` tag, we also want to add some margin to our `#bell-icon` so that it looks good next to the other icons.

```css theme={null}
.toolbar #bell-icon {
  height: '';
  margin: 0 16px;
}
```

Run your app again. Now you should see the bell icon (the notification center) in the toolbar section of your app.

You should now see a **bell button** that opens the notification center when clicked. This bell can be customized to your preference.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Note: There are no notifications because none has been triggered yet. When notifications are sent to a subscriber, it will show up in the UI. Next, we'll learn how to trigger notifications.

* [Angular Notification Center Example Repo](https://github.com/novuhq/examples/tree/main/novu-angular-notification-center)

## Create A Workflow

The first step to trigger notifications is to create a workflow. A workflow is like a map that holds the entire flow of messages sent to the subscriber.

The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **“Create Workflow”** button on the top right.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select **"In-App"** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added In-App channel and configure it according to your preferences. Once you’re done, click Update to save your configuration.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).

Feel free to add only text for now and rename the workflow to `Onboarding In App`. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Next, we’ll learn how to create subscribers on Novu - *Recipients of Notifications*

## Create A Subscriber

Click **Subscribers** on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-angluar) to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu.

Novu has a plethora of backend SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin) to choose from to create a subscriber programmatically. This is the recommended method.

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.identify('123', {
  firstName: 'Emil',
  lastName: 'Pearce',
  returnUser: true,
});
```

Obtain your API key from your [Novu dashboard.](https://web.novu.co/settings?utm_campaign=docs-quick-angluar) Replace `<NOVU_API_KEY>` with it.

Now check your Novu dashboard. You should see the recently created subscriber.

You can also update the subscriber info like so:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('123', {
  firstName: 'Emil', // new first name
  lastName: 'Pearce', // new last name
});
```

## Trigger A Notification

To trigger a notification, simply run the code below with the correct credentials.

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.trigger('onboarding-in-app', {
  to: {
    subscriberId: '132',
  },
});
```

`onboarding-in-app` is the workflow identifier we created earlier.

Ensure the `subscriberId` value in the backend code that triggers the notification matches the `subscriberId` in your `my-app/src/environments/environment.ts` code.

```jsx theme={null}
export const environment = {
  production: false,
  subscriberId: '',
  applicationIdentifier: '',
};
```

Check your app again. You should see the recently triggered notification!

## Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, configured a channel provider and triggered a notification in your Angular application.


# General
Source: https://v0.x-docs.novu.co/quickstarts/general

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications.

To create your free managed, or docker-based Novu environment use our CLI tool:

```
npx novu init
```

After creating your cloud or self-hosted account, the next steps to sending your first notification are outlined in this guide:

* Connect your providers
* Create a workflow
* Send a trigger
* Integrate the [Notification Center](https://docs.novu.co/notification-center/getting-started) within your app *(optional)*

# Connect providers

On the **Integration Store** page, you can configure the different providers and their respective credentials. During the alpha phase only a **single provider** is allowed **per channel**, adding a second email provider will de-activate the previously added email provider.

# Create a workflow

After configuring the designated channel provider, you can create your workflow. You can think of the workflow as the blueprint for the notifications that will be sent. The workflow includes:

* Workflow details
* Channel specific content
* Trigger definition

### Workflow Details

The **name** of the workflow is converted to a slug that is used as the trigger identifier which is used when sending the trigger from the back-end.

### Channel specific content

### Email

You can specify the content for emails in two ways:

**Visual workflow builder** - For simple use cases, you can use our visual workflow editor. The visual workflow builder has limited control over design but is easier to get-started with.

**Custom Code** - You can use the custom code section to specify custom html for the email.

You can specify custom variables using the [handlebars](https://handlebarsjs.com/guide/) syntax.

### SMS

Inside SMS, you can specify custom variables using [handlebars](https://handlebarsjs.com/guide/) syntax.

### In-app

In the notification center preview, you can type the content of the notification, select the content, and use `CMD` + `B` to make the selected text bold.

### Chat

You can specify custom variables using the [handlebars](https://handlebarsjs.com/guide/) syntax.

In addition to the integration, any subscriber needs to set credentials to have proper authorization on the channel.

The credentials can be saved through our `@novu/node` package.

# Trigger the workflow

After creating the workflow, Novu generates the trigger. Use the server SDK in your application in the appropriate place for the specific trigger.

```tsx theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<USER_IDENTIFIER>',
    email: 'email@email.com',
    firstName: 'John',
    lastName: 'Doe',
  },
  payload: {
    customVariables: 'Hello',
  },
});
```

The trigger function contains a parameters object as the second parameter. Let's explore its different options:

### `to` key

The `to` parameter contains the information about the subscriber of the notification. You can work with Novu in 2 modes:

### Pass the subscriber information in the trigger (Quickest)

You can pass the subscriber object containing the following keys as this parameter:

```tsx theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
    firstName,
    lastName,
    email,
    phone,
    avatar,
    locale,
  },
  payload: {},
});
```

The `subscriberId` is a custom identifier that identifies users within the Novu platform. We suggest using your internal DB identifier for this field.

When the trigger is called, Novu performs an upsert command, which either creates a subscriber with the specified payload, or updates the existing subscriber with the passed information.

**Note:** The API performs a PATCH command, updating only the fields passed to it. So to reset a specific field, you must explicitly pass `null` as the fields param.

### Pass only the `subscriberId` (Recommended)

```tsx theme={null}
{
  to: 'SUBSCRIBER_ID',
  payload: {}
}
```

In this approach, you only pass the `subscriberId` as part of the trigger, however, this approach requires you to identify the subscriber using the `identify` method from the `@novu/node`library.

### `payload` object

The `payload` object can pass any serializable JSON object to be used in the workflows.


# Go quickstart
Source: https://v0.x-docs.novu.co/quickstarts/go

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Go.

## Go Quickstart

Welcome to Go Quickstart guide for Novu. In this guide, you'll learn how to use Novu in a Go application. Novu is a powerful notification service that enables you to send multi-channel (SMS, Email, Chat, Push) notifications. Let's see how you can seamlessly integrate Novu into your Go project!

## Prerequisites

Before diving into the Quickstart, make sure you have the following:

* The [Go SDK](https://go.dev/doc/install) installed on your development machine.
* A Novu account. If you don't have one, sign up for free [here](https://web.novu.co?utm_campaign=docs-gs-quick-go)

## Install and Set Up Novu in your Go Project

First, you must install the Novu package in your Go project. From your terminal, you can install the Novu package in your project by running the following command:

```bash theme={null}
go get github.com/novuhq/go-novu

```

Once installed, you can import Novu into your project and initialize it using your Novu account credentials. This step establishes a connection between your app and the Novu notification service.

```go theme={null}
import (
 novu "github.com/novuhq/go-novu/lib"
)

novuClient := novu.NewAPIClient("<NOVU_API_KEY>", &novu.Config{})

```

Replace `<NOVU_API_KEY>` with your own API key that you got from the API Key section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-go).

<Note>
  🔑 Note: Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

## Configure retry

```go theme={null}
import (
 novu "github.com/novuhq/go-novu/lib"
)

novuClient := novu.NewAPIClient(apiKey, &novu.Config{RetryConfig: &novu.RetryConfigType{RetryMax: 3, WaitMin: 1 * time.Second, WaitMax: 5 * time.Second, InitialDelay: 0 * time.Second}})

```

| Options      | Detail                                                          | Default Value |
| ------------ | --------------------------------------------------------------- | ------------- |
| RetryMax     | Specifies total number of retries to perform in case of failure | 0             |
| WaitMin      | Specifies the minimum time to wait before retrying              | 0             |
| WaitMax      | Specifies the maximum time to wait before retrying              | 0             |
| InitialDelay | Specifies the initial delay before the first retry attempt      | 0             |

<Info>
  Above retry configuration is applied to all the sdk methods.
</Info>

## Set Up A Channel Provider

A channel provider is a service that lets you use one or more notification channels such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-go) currently supports four channels: Email, SMS, Chat, and Push. Each of these channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel** at a time. Connect anyone of your preferred providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Notification Workflow

A notification workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber.

The workflow includes the following:

* Notification workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be setup for the Chat channel.
</Note>

To create a notification workflow, please follow the following steps:

1. Click **Workflows** on the left sidebar of your Novu dashboard.

2. Click the **Create Workflow** button on the top right.

3. Select **blank workflow** from the dropdown.

4. The name of a new workflow is currently "Untitled." Rename it to a suitable title.

5. Select any channel you want to use in your app. For the sake of this guide, we'll be using the 'Email' channel.
   <Frame>
     <img />
   </Frame>

6. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

7. Click on the “Test” tab and send a test email to verify your notification workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. If you didn't, please check your 'spam' folder as sometimes test emails can end up there. Yaaay, you have successfully sent your first notification via the Novu dashboard!

Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display only one subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)


## Create a subscriber
func main() {
    ctx := context.Background()
    subscriberID := "<REPLACE_WITH_YOUR_SUBSCRIBER>"
    subscriber := novu.SubscriberPayload{
     LastName: "Skjæveland",
     Email:    "benedicte.skjaeveland@example.com",
     Avatar:   "https://randomuser.me/api/portraits/thumb/women/79.jpg",
     Data: map[string]interface{}{
      "location": map[string]interface{}{
       "city":     "Ballangen",
       "state":    "Aust-Agder",
       "country":  "Norway",
       "postcode": "7481",
      },
     },
    }

 resp, err := novuClient.SubscriberApi.Identify(ctx, subscriberID, subscriber)
 if err != nil {
  log.Fatal("Subscriber error: ", err.Error())
  return
 }

 fmt.Println(resp)
}

```

Run the code in your terminal like so:

```bash theme={null}
go run main.go # replace main.go with your file name

```

You should see a new subscriber (that you created above) on your Novu dashboard.

## Update A Subscriber

To update the Subscriber details you can call the put method from SubcriberApi. Here is an example:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Update subscriber details
func main() {
    ctx := context.Background()
    subscriberID := "<REPLACE_WITH_YOUR_SUBSCRIBER>"
    updateSubscriber := novu.SubscriberPayload{FirstName: "Susan"}
 updateResp, err := novuClient.SubscriberApi.Update(ctx, subscriberID, updateSubscriber)
 if err != nil {
  log.Fatal("Update subscriber error: ", err.Error())
  return
 }

 fmt.Println(updateResp)
}

```

<Note>
  Note: To send notifications to all your users, you'll need to make them subscribers in Novu, which you can do by programmatically adding them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Trigger A Notification
func main() {
    subscriberID := "<REPLACE_WITH_YOUR_SUBSCRIBER>"
 apiKey := "<REPLACE_WITH_YOUR_API_KEY>"
 eventId := "<REPLACE_WITH_YOUR_EVENT_ID>"

 ctx := context.Background()
 to := map[string]interface{}{
  "lastName":     "Nwosu",
  "firstName":    "John",
  "subscriberId": subscriberID,
  "email":        "johnnwosu@email.com",
 }
 payload := map[string]interface{}{
  "name": "Hello World",
  "organization": map[string]interface{}{
   "logo": "https://happycorp.com/logo.png",
  },
 }
 
 novuClient := novu.NewAPIClient(apiKey, &novu.Config{})
 triggerResp, err := novuClient.EventApi.Trigger(ctx, eventId, novu.ITriggerPayloadOptions{
  To:      to,
  Payload: payload,
 })
 if err != nil {
  log.Fatal("Novu error", err.Error())
  return
 }

 fmt.Println(triggerResp)
}

```

Before running the code, make sure you understand the following:

* The value of `eventId` should be the notification workflow's trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the notification template content.
* The value of `subscriberId` is the id of the subscriber on Novu.

Replace all items with their respective and accurate values.

Run the code to trigger a notification!

```bash theme={null}
go run main.go # replace main.go with your file name

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Create Topic
func main() {
    ctx := context.Background()
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
    topicName := "<REPLACE_WITH_YOUR_TOPIC_NAME>"
 createResp, err := novuClient.TopicsApi.Create(ctx, topicKey, topicName)
 if err != nil {
  log.Fatal("Create topic error: ", err.Error())
  return
 }

 fmt.Println(createResp)
}

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

## Add subscriber to Topic
func main() {
    ctx := context.Background()
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
    subscribers := []string{"<SUBSCRIBER_ID_1>", "<SUBSCRIBER_ID_2>"}
 addSubscribersResp, err := novuClient.TopicsApi.AddSubscribers(ctx, topicKey, subscribers)
 if err != nil {
  log.Fatal("Add subscriber to topic error: ", err.Error())
  return
 }

 fmt.Println(addSubscribersResp)
}

```

On the other hand, if you want to remove subscribers from a topic, do the following:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

## Remove subscriber from Topic
func main() {
    ctx := context.Background()
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
    subscribers := []string{"<SUBSCRIBER_ID_1>", "<SUBSCRIBER_ID_2>"}
 removeSubscribersResp, err := novuClient.TopicsApi.RemoveSubscribers(ctx, topicKey, subscribers)
 if err != nil {
  log.Fatal("Add subscriber to topic error: ", err.Error())
  return
 }

 fmt.Println(addSubscribersResp)
}

```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Trigger A Notification
func main() {
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
 apiKey := "<REPLACE_WITH_YOUR_API_KEY>"
 eventId := "<REPLACE_WITH_YOUR_EVENT_ID>"
 ctx := context.Background()
 
 to := map[string]interface{}{
  "type":     "Topic",
  "topicKey":    topicKey
 }
 payload := map[string]interface{}{
  "name": "Hello World",
  "organization": map[string]interface{}{
   "logo": "https://happycorp.com/logo.png",
  },
 }
 
 novuClient := novu.NewAPIClient(apiKey, &novu.Config{})
    triggerResp, err := novuClient.EventApi.Trigger(ctx, eventId, novu.ITriggerPayloadOptions{
      To:      to,
      Payload: payload,
     })
 if err != nil {
  log.Fatal("Novu error", err.Error())
  return
 }

 fmt.Println(triggerResp)
}

```

## Next Steps

Great job! If you've reached this point, you should now have successfully created a subscriber, notification workflow, configured a channel provider and triggered a notification in your application.

To learn more about notifications and explore Novu's features and capabilities, check out:

* [Novu Digest Engine](https://docs.novu.co/platform/digest) - Learn how to aggregate multiple trigger events into a single message and deliver it to the subscriber.
* [Novu Go SDK](https://github.com/novuhq/go-novu) - Delve deeper into the SDK and explore a lot of features.
* [Novu Notification Center](/getting-started/introduction) - Learn how to integrate a rich, ready-to-use real-time UI notification center into your app.


# iFrame
Source: https://v0.x-docs.novu.co/quickstarts/iFrame

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with iFrame embed

## Requirements

To follow the steps in this quickstart, you’ll need:

* A Novu account. **[Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-iframe)** if you don’t have one yet.
* Basic knowledge of HTML and JavaScript.

You can also **[view the completed code](https://github.com/novuhq/iframe-quickstart)** of this quick start in a GitHub repo.

## Create a workflow

Before triggering a notification, we need to create a workflow. A workflow is like a blueprint that all the notifications are supposed to follow.

> The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

These are the steps to create a workflow:

1. Click **Workflow** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **“Untitled”**. Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.

<img />

Select the in-app channel.

1. Click on the recently added “In-App” channel and configure it according to your preferences. Once you’re done, click “Update” to save your configuration.

<img />

Configure the in-app node as per your needs.

I’ll briefly explain the function of each label in the image above:

* **1-Preview**: This shows you a glimpse of how each notification item will look in the Notification Center UI.
* **2-Avatar**: If turned on, each notification item will show the avatar of the subscriber.
* **3-Action**: With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds**: This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL**: This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter**: This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber’s online status to send them an email if they were online within the last hour. Read [more about filters](/workflows/notification-workflows).
* **7-Editor**: You can add text that you want to be displayed in each notification item. Additionally, you can specify custom variables using **`{{ }}`**. This means you can inject variables from your code into a notification item’s text via a payload.

In our case, we’ll use the custom variables functionality, as shown below:

<img />

We're gonna use custom variables here.

Feel free to add only text for now and rename the workflow to quickstart. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.
Rename the workflow to 'quickstart'.

<img />

Now, we’ll learn how to create subscribers on Novu - Recipients of Notifications!

## Create a subscriber

If you click “Subscriber” on the left sidebar of the **[Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-iframe)**, you’ll see the subscriber list. By default, there will only be one subscriber as you’re automatically added as a subscriber when you sign up for Novu:

<img />

<Note> One subscriber is automatically created when you sign up. If you don't see the default subscriber, follow [how to create subscriber](/subscribers/subscribers#create-a-subscriber) documentation to learn on how to create one </Note>

Now, let’s create a subscriber on Novu. After creating a subscriber, we’ll trigger a notification to this subscriber. Subscribers are identified by a unique **`subscriberId`**.

With Novu, you can create a subscriber using any of its SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin). The code to create a subscriber in Novu is:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.identify('123', {
  firstName: 'Sumit',
  lastName: 'Saurabh',
});
```

You can get your API key from the Novu dashboard. Replace **`<NOVU_API_KEY>`** with it. Now, if you’ll go to the Novu dashboard, you shall see the subscriber we created above with **`subscriberId`** of **`123`**.

You can also update information about an already existing subscriber using the **`subscriber.update`** method as shown below:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('123', {
  firstName: 'Saurabh', // new first name
  lastName: 'Sumit', // new last name
});
```

## Embed iFrame Notification Center in a your web app

1. Create a simple HTML file, you can call it `index.html`

2. Copy the following code snippet, it contains a basic html structure with some design elements to make things look more pretty

   <Note> Note that we are using fontAwesome library as a stylesheet dependency. </Note>

   ```html theme={null}
   <!DOCTYPE html>
   <html lang="en">

   <head>
       <meta charset="UTF-8">
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css">

       <title>iFrame Quickstart</title>
       <style>
           body {
               font-family: Arial, sans-serif;
               background-color: #f4f4f4;
               margin: 0;
               padding: 0;
               display: flex;
               justify-content: center;
               align-items: top;
               min-height: 100vh;
           }

           .container {
               text-align: center;
               padding: 20px;
               border-radius: 10px;
               background-color: #ffffff;
               box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.1);
           }

           h1 {
               color: #333333;
           }

           p {
               color: #666666;
               line-height: 1.6;
           }

           .fa {
               cursor: pointer;
           }

           .fa:hover {
               color: #0056b3;
           }
       </style>
   </head>

   <body>

       <div class="container">
           <h1>iFrame Notification Center Icon Bell</h1>
           <div id="notification-bell">
               <i class="fa fa-bell fa-2x"></i>
               <span id="unseen-badge"></span>
           </div>
           <p>Click on the notification bell to see the feed</p>
       </div>
       </div>

       <script>
       </script>
   </body>

   </html>
   ```

3. To activate the iFrame, you should include the following code as a script in your html app.

   ```jsx theme={null}
   <script>
     (function(n,o,t,i,f) {
       n[i] = {}; var m = ['init', 'on']; n[i]._c = [];m.forEach(me => n[i][me] = function() {n[i]._c.push([me, arguments])});
       var elt = o.createElement(f); elt.type = "text/javascript"; elt.async = true; elt.src = t;
       var before = o.getElementsByTagName(f)[0]; before.parentNode.insertBefore(elt, before);
     })(window, document, 'https://embed.novu.co/embed.umd.min.js', 'novu', 'script');

     novu.init(
       '<REPLACE_applicationIdentifier>',
       {
         unseenBadgeSelector: '#unseen-badge',
         bellSelector: '#notification-bell',
       },
       {
         subscriberId: '<REPLACE_WITH_subscriberId>',
       }
     );
   </script>
   ```

   You’ll notice two things used above - **`applicationIdentifier`** and **`subscriberID`**.

   An application identifier is a public key used to identify your application. You can get your own application identifier from the **[Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-iframe)**.

   And subscribers are users to which notifications will be sent. They are identified by a **`subscriberID`** which you can also find in the **[Novu subscribers dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-iframe)**.

4. Now open your html application, you should see something like this:

<img />

If you have replaced the `applicationIdentifier` and `subscriberID`, when you will click the bell, you will see the following:

<img />

To learn how to design and modify your iFrame component, feel free to visit the more in-depth [iFrame section](notification-center/client/iframe).

## Trigger a notification

We can trigger a notification by simply clicking on the `Get Snippet` button

<img />

Switch to `Run a Test` option

<img />

Change the `subscriberId` that we have created (`123`)

<img />

Click on `Run Trigger`

<img />

This will take the workflow we created above with the identifier `quickstart` and send a notification to the subscriber with `subscriberId` of `123`.

Now we will open our web application and see a red dot next to the bell icon, this indicate that we have an unseen notification in our feed.

When we will click on it, we will see our notification.

<img />

## Conclusion

Great job! If you’ve reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, triggered a notification and saw it in your web application using iFrame embed.

If you want to learn more about iFrame embed component, please visit [this section](/notification-center/client/iframe) of the documentation.


# Java quickstart
Source: https://v0.x-docs.novu.co/quickstarts/java

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Java.

## Java Quickstart

Learn how to integrate Novu into your Java project on the fly and send notifications across different channels (SMS, Email, Chat, Push).

In this Quickstart, you will learn how to:

* [Install and Set up the Novu Java SDK.](#install-and-set-up-the-novu-java-sdk-in-your-project)
* [Configure a Notification Channel Provider.](#set-up-a-channel-provider)
* [Set up a Notification Workflow.](#create-a-notification-workflow)
* [Create a Subscriber and update a Subscriber's information.](#create-a-subscriber-and-update-a-subscribers-information)
* [Send your first Notification to a Subscriber.](#trigger-a-notification)
* [Send Notifications via Topics.](#topics)

Let's get started! :muscle:

## Requirements

To be able to use this Quickstart, you would need to have the following:

* A Novu account, if you don't have one yet, [sign up](https://web.novu.co?utm_campaign=docs-gs-quick-java) for free.
* A working Java development environment with JDK 17 and Springboot Framework of 3.1.2+.

The completed code for this quick start is available on GitHub. Check it out [here](https://github.com/novuhq/novu-java-quickstart).

## Install and Set up the Novu Java SDK in your project

First, you need to import the library into your application.
If you use Maven, add the dependency to the `pom.xml` file;

```xml theme={null}
<dependency>
  <groupId>co.novu</groupId>
  <artifactId>novu-java</artifactId>
  <version>{use-latest-version}</version>
</dependency>
```

The latest version can be found [on GitHub.](https://github.com/novuhq/novu-java#installation)

If you use Gradle, add the dependency to the `build.gradle` file;

```groovy theme={null}
dependencies {
  implementation 'co.novu:novu-java:{use-latest-version}'
}
```

Sync your project, and you should have the artifacts downloaded.

To use the SDK, you need to have your API key handy, it can be gotten from [settings page](https://web.novu.co/settings?utm_campaign=docs-quick-java) of the web dashboard.

To initialize the library, you can create an instance of `Novu.java` class using any of the following constructors:

```java theme={null}
//Using the API Key only
String apiKey = "INSERT_API_KEY_HERE";
  Novu novu = new Novu(apiKey);
```

```java theme={null}
//Using the API Key plus an instance of NovuConfig
String apiKey = "INSERT_API_KEY_HERE";
  NovuConfig novuConfig = new NovuConfig(apiKey);
  Novu novu = new Novu(novuConfig);
```

Once that is done successfully, head over to the [web dashboard](https://web.novu.co?utm_campaign=docs-quick-java) for the next steps.

## Set up a Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification, etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-java) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favorite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Notification Workflow

A notification workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Notification workflow name and Identifier.
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a notification workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.

<Frame>
  <img />
</Frame>

3. The name of a new notification workflow is currently **Untitled**, rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select **Email** as the channel you want to add, by dragging it from the right sidebar.

<Frame>
  <img />
</Frame>

5. Click on the **Email** in the workflow and edit it as per this image. Don't forget to add the fields in the editor which is supposed to be updated with dynamic values that will be sent when calling the API.
   <Frame>
     <img />
   </Frame>

6. Also, add the variables in the **Variables** section in the test tab and try testing it by sending the email to your email address using the **Send Test Email** button at the bottom right.
   <Frame>
     <img />
   </Frame>

You should get an email within seconds! :ok\_hand:

Great, you have successfully sent your first notification via the Novu dashboard! Now, let's take a step further to trigger notifications via code.

## Create and Update a Subscriber's Information

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);

    SubscriberRequest subscriberRequest = new SubscriberRequest();
        subscriberRequest.setEmail("email");
        subscriberRequest.setFirstName("fName");
        subscriberRequest.setLastName("lName");
        subscriberRequest.setPhone("phone");
        subscriberRequest.setAvatar("avatar");
        subscriberRequest.setSubscriberId("subscriberId");
            try {
                return novu.createSubscriber(subscriberRequest);
            }catch (Exception e){
                log.error("Error Creating Subscriber", e);
            }

            return null;
```

When you run this code snippet, you should see the subscriber on your Novu dashboard.

Now, let's assume you want to modify the email address of the subscriber you just created, you can do that with the following code:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);

    UpdateSubscriberRequest updateSubscriberRequest = new UpdateSubscriberRequest();
        updateSubscriberRequest.setEmail("updatedEmail");
        updateSubscriberRequest.setFirstName("fName");
        updateSubscriberRequest.setLastName("lName");
        updateSubscriberRequest.setPhone("phone");
        updateSubscriberRequest.setAvatar("avatar");

        String subscriberId = "subscriberId";

        try {
            return novu.updateSubscriber(updateSubscriberRequest, subscriberId);
        }catch (Exception e){
            log.error("Error updating Subscriber", e);
        }

        return null;
```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an Object or a Map with the info you want to attach to the subscriber.

<Note>
  To create all of your subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger a Notification

Copy and paste the following code into your app to trigger a notification to a Subscriber:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);

    SubscriberRequest subscriberRequest = new SubscriberRequest();
            subscriberRequest.setSubscriberId("subscriberId");
            subscriberRequest.setEmail("email;");
            subscriberRequest.setFirstName("fName");
            subscriberRequest.setLastName("lName");

    TriggerEventRequest triggerEventRequest = new TriggerEventRequest();
            triggerEventRequest.setName("name");
            triggerEventRequest.setTo(subscriberRequest);
            triggerEventRequest.setPayload(Collections.singletonMap("customVariables", "Hello"));


    try {
        return novu.triggerEvent(triggerEventRequest);
    }catch (Exception e){
        log.error("Error triggering event", e);
    }

            return null;
```

Before running the code, make sure you understand the following:

* The value of `payload` is an array of the data that you want to be dynamically injected into the notification workflow content.
* The value of `subscriberId` is the ID of the subscriber on Novu. Replace `12345` with your subscriber ID.

Run the code to trigger a notification!

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops. A topic is identified by a custom key that is provided by the user, and this key will be the identifier used in the Topics API.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also caters for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```java theme={null}
String apiKey = "API_KEY";
Novu novu = new Novu(apiKey);

TopicRequest createTopicRequest = new TopicRequest();
    createTopicRequest.setKey("key");
    createTopicRequest.setName("name");
        try {
            return novu.createTopic(createTopicRequest);
        }catch (Exception e){
            log.error("Error creating Topic", e);
        }

        return null;
```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add Subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```java theme={null}
String apiKey = "API_KEY";
Novu novu = new Novu(apiKey);

        String topicKey = "key";
        SubscriberAdditionRequest requestBody = new SubscriberAdditionRequest();
        requestBody.setSubscribers(Collections.singletonList("aSubscriberId"));

        try {
            return novu.addSubscriberToTopic(requestBody,topicKey);
        }catch (Exception e){
            log.error("Error Adding Subscriber To Topic", e);
        }

        return null;
```

On the other hand, if you want to remove subscribers from a topic, do the following:

```java theme={null}
String apiKey = "API_KEY";
Novu novu = new Novu(apiKey);


        String topicKey = "key";
        SubscriberAdditionRequest requestBody = new SubscriberAdditionRequest();
        requestBody.setSubscribers(Collections.singletonList("aSubscriberId"));

        try {
            return novu.removeSubscriberFromTopic(requestBody, topicKey);
        }catch (Exception e){
            log.error("Error Removing Subscriber From Topic", e);
        }

        return null;
```

## Send a Notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);


    Topic topic = new Topic();
        topic.setType("Topic");
        topic.setTopicKey("topicKey");

    TriggerEventRequest triggerEventRequest = new TriggerEventRequest();
            triggerEventRequest.setName("name");
            triggerEventRequest.setTo(topic);
            triggerEventRequest.setPayload(Collections.singletonMap("customVariables", "Hello"));


    try {
        return novu.triggerEvent(triggerEventRequest);
    }catch (Exception e){
        log.error("Error sending notification to topic", e);
    }

            return null;
```

## Next Steps

Great job! :clap: If you've reached this point, you should have successfully created a subscriber, notification workflow, configured a channel provider, triggered a single notification, created a topic, added a subscriber to a topic in your application.

To learn more about notifications and explore Novu's features and capabilities, check out:

* [Novu Java SDK](https://github.com/novuhq/novu-java) - Dive deeper into the SDK and explore a lot of features.
* [Novu Digest Engine](/guides/add-digest-to-inapp-notifications) - Learn how to aggregate multiple trigger events into a single message and deliver it to the subscriber.
* [Novu Notification Center](/getting-started/introduction) - Learn how to integrate a rich, ready-to-use real-time UI notification center into your app.


# Kotlin quickstart
Source: https://v0.x-docs.novu.co/quickstarts/kotlin

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Kotlin.

Learn how to integrate Novu into your Kotlin project on the fly and send notifications across different channels (SMS, Email, Chat, Push).

Let's get started! 💪

## Requirements

To be able to use this Quickstart, you would need to have the following:

* A Novu account, if you don't have one yet, [sign up](https://web.novu.co/?utm_campaign=docs-gs-quick-kotlin) for free.
* A working Kotlin project running version 1.6.0+ and Kotlin compiler 1.8.0+.

The completed code for this quick start is available on GitHub. Check it out [here](https://github.com/novuhq/novu-kotlin-quickstart).

## Install and Set up the Novu Kotlin SDK in your project

First, you need to import the library into your application.

If you use Maven, add the dependency to the `pom.xml` file;

```xml theme={null}
<dependency>
  <groupId>co.novu</groupId>
  <artifactId>novu-kotlin</artifactId>
  <version>{use-latest-version}</version>
</dependency>
```

The latest version can be found [on GitHub.](https://github.com/novuhq/novu-kotlin#installation)

If you use Gradle, add the dependency to the `build.gradle` file;

```groovy theme={null}
implementation 'co.novu:novu-kotlin:{use-latest-version}' //Groovy

implementation ("co.novu:novu-kotlin:{use-latest-version}") //Kotlin
```

Sync your project, and you should have the artifacts downloaded.

To use the SDK, you need to have your API key handy, it can be gotten from the [settings page](https://web.novu.co/settings?utm_campaign=docs-quick-kotlin) of the web portal.

To initialize the library, you can create an instance of `Novu.kt` class using any of the following constructors:

```kotlin theme={null}
//Using the API Key only
val novu = Novu(apiKey = "API_KEY")

```

```kotlin theme={null}
//Using the API Key plus an instance of NovuConfig
val novuConfig = NovuConfig(backendUrl = "URL")
val novu = Novu(apiKey = "API_KEY", config = novuConfig)

```

Once that is done successfully, head over to the [web portal](https://web.novu.co/?utm_campaign=docs-quick-kotlin) for the next steps.

## Set up a Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification, etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-kotlin) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favourite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier.
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.

<Frame>
  <img />
</Frame>

3. The name of the new workflow is currently Untitled, rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select Email as the channel you want to add, by dragging it from the right sidebar.

<Frame>
  <img />
</Frame>

5. Click on the Email in the workflow and edit it as per this image. Don’t forget to add the fields in the editor which is supposed to be updated with dynamic values that will be sent when calling the API.

<Frame>
  <img />
</Frame>

6. Also, add the variables in the Variables section in the test tab and try testing it by sending the email to your email address using the Send Test Email button at the bottom right.

<Frame>
  <img />
</Frame>

You should get an email within seconds! 👌

Great, you have successfully sent your first notification via the Novu dashboard! Now, let’s take a step further to trigger notifications via code.

## Create a Subscriber and Update a Subscriber's information

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```kotlin theme={null}
suspend fun createSubscriber(): ResponseWrapper<SubscriberResponse>? {
        val novu = Novu(apiKey = "API_KEY")
        val subscriberRequest = SubscriberRequest(
            email = "email@sample.com",
            firstName = "John",//optional
            lastName = "Doe",//optional
            phone = "123456789",//optional
            avatar = "sample-avatar",//optional
            subscriberId = "12345"//optional
        )
        return CoroutineScope(Dispatchers.IO).async {
            novu.createSubscriber(subscriberRequest)
        }.await()
    }

```

When you run this code snippet, you should see the subscriber on your Novu dashboard. 👤

Now, let's assume you want to modify the email address of the Subscriber you just created, you can do that with the following code:

```kotlin theme={null}
suspend fun updateSubscriber(): ResponseWrapper<SubscriberResponse>? {
        val novu = Novu(apiKey = "API_KEY")
        val subscriberRequest = UpdateSubscriberRequest(
            email = "validemail@sample.com",
            firstName = "John",//optional
            lastName = "Doe",//optional
            phone = "123456789",//optional
            avatar = "sample-avatar"//optional
        )
        val subscriberId = "12345"
        return CoroutineScope(Dispatchers.IO).async {
            novu.updateSubscriber(subscriberId, subscriberRequest)
        }.await()
    }

```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an Object or a Map with the info you want to attach to the subscriber.

<Note>
  To create all of your subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger a Notification

Copy and paste the following code into your app to trigger a notification to a Subscriber:

```kotlin theme={null}
suspend fun triggerNotification(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val triggerEventRequest = TriggerEventRequest(
            name = "test",
            to = SubscriberRequest(
                subscriberId = "12345",
                email = "email@email.com",
                firstName = "John",
                lastName = "Doe"
            ),
            payload = mapOf("customVariables" to "Hello")
        )

        return CoroutineScope(Dispatchers.IO).async {
            novu.trigger(triggerEventRequest)
        }.await()
    }

```

Before running the code, make sure you understand the following:

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the ID of the subscriber on Novu. Replace `12345` with your subscriber ID.

Run the code to trigger a notification! 📧

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops. A topic is identified by a custom key that is provided by the user, and this key will be the identifier used in the Topics API.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also caters for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```kotlin theme={null}
suspend fun createTopic(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val createTopicRequest = CreateTopicRequest(
            key = "key",
            name = "name"
        )
        return CoroutineScope(Dispatchers.IO).async {
            novu.createTopic(createTopicRequest)
        }.await()
    }

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```kotlin theme={null}
suspend fun addSubscriberToTopic(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val topicKey = "key"
        val requestBody = SubscriberList(listOf("name"))
        return CoroutineScope(Dispatchers.IO).async {
            novu.addSubscribers(topicKey, requestBody)
        }.await()
    }

```

On the other hand, if you want to remove subscribers from a topic, do the following:

```kotlin theme={null}
suspend fun removeSubscriberFromTopic(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val topicKey = "key"
        val requestBody = SubscriberList(listOf("name"))
        return CoroutineScope(Dispatchers.IO).async {
            novu.removeSubscriber(topicKey, requestBody)
        }.await()
    }

```

## Sending a Notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```kotlin theme={null}
suspend fun triggerNotificationToTopic(): Any? {
        val novu = Novu(apiKey = "NOVU_API_KEY")
        val triggerEventRequest = TriggerEventRequest(
                name = "test",
                to = listOf(
                        Topic(
                                type = "Topic",
                                topicKey = "posts:comment:12345"
                        )
                ),
                payload = mapOf("customVariables" to "Hello")
        )

        return CoroutineScope(Dispatchers.IO).async {
            novu.trigger(triggerEventRequest)
        }.await()
    }
```

## Conclusion

Great job! 👏
If you've reached this point, you should have successfully created a subscriber, workflow, configured a channel provider, triggered a single notification, created a topic, and added a subscriber to a topic in your application.


# NextJS
Source: https://v0.x-docs.novu.co/quickstarts/nextjs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with NextJS.

This quick start guide is written to help you integrate Novu into your NextJS app in no time. Novu is an open-source notifications infrastructure that you can use in your app to deliver rich notifications across channels like sms, email, in-app, push, chat, etc. In this guide, you’ll learn how to integrate email notifications into your NextJS app.

You can find the code for this app [here](https://github.com/novuhq/nextjs-quickstart/)

## Prerequisites

* Node.js installed on your development machine (to create a NextJS app).
* A Novu account. If you don't have one, sign up for free [here](https://web.novu.co/workflows?utm_campaign=docs-quick-nextjs).

## Create a NextJS app to get started

The first step here would be to create a NextJS app. We will play with Novu in this app later. To get started, open your terminal and create a NextJS app using the following command:

```bash theme={null}
npx create-next-app@latest

```

This will create a NextJS app and now we can add Novu to our project. Open the app using a code editor of your choice. The benefit of using NextJS is that it provides native support for routing, making it effortless to handle navigation and create dynamic pages in your application.

Next.js uses a file-based routing system, where each page in your application is represented by a corresponding file in the `pages` directory.

By creating a new file in the `pages` directory, such as `about.js`, we automatically create a route `/about` in our application. Next.js handles the routing logic behind the scenes, ensuring that when a user accesses `/about`, the corresponding page component is rendered.

In our app, we’ll create a route that will send an email notification to a specified email id. To do this, we need two things:

* Install Novu and connect it to our app
* Create the route and define a function in that route

## Installing Novu and connecting it to the app

To install Novu, simply open your terminal and issue the following command:

```bash theme={null}
npm install @novu/node

```

After installing it, we need to connect our app with our Novu account using the Novu API key. Simply log onto the [Novu web dashboard](https://web.novu.co?utm_campaign=docs-quick-nextjs/) and from the settings there, obtain your API key. We’ll use it to connect our app to our Novu account.

<Frame>
  <img />
</Frame>

Now, we need to connect it to our app. To do so, the first step is to import Novu into our app. Importing Novu will give us the ability to interact with the Novu API. To import Novu into our app, use the following code in a separate file in our app:

```jsx theme={null}
import { Novu } from '@novu/node';

// replace <NOVU_API_KEY> with your actual API key
const novu = new Novu(<NOVU_API_KEY>);
```

Novu lets us send notifications across different channels like email, in-app, chat, SMS, etc, and for each channel, one can use a plethora of providers. You just need to set up a provider for the channel you want to use in Novu:

| Channel | Providers                                                           |   |
| ------- | ------------------------------------------------------------------- | - |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |   |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |   |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |   |
| Push    | FCM, APNS, Expo                                                     |   |

You can see all this in our [integrations store](https://web.novu.co/integrations?utm_campaign=docs-quick-nextjs) and set it up there.

For each channel, there can be only one provider active at a time. Although the exact setup process varies from provider to provider, the general flow is signing up for a provider, getting an API key from its portal, and plugging it into the Novu web portal.

Once having integrated a provider, we need a workflow to send notifications. One can have dynamic data in this workflow if they so choose.

In our case, we’ll have dynamic data and whatever we send as a description will be sent as an email notification. Following are the steps to create a workflow.

## Creating a workflow

1. Click "Workflows” on the left sidebar of your Novu dashboard.
2. Click the “Create Workflow” button on the top right.

<Frame>
  <img />
</Frame>

3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select "Email" as the channel you want to add, by dragging it from the right sidebar:

<Frame>
  <img />
</Frame>

5. Click on the ‘Email’ in the workflow and edit it as per this image. Don’t forget to add the fields in the editor which is supposed to be updated with dynamic values that we’ll send when calling the API.

<Frame>
  <img />
</Frame>

6. Also, add the variables in the ‘variables’ section in the test tab and try testing it by sending the email to your email id using the ‘send test email’ button on the bottom right.

<Frame>
  <img />
</Frame>

Now, we’ve successfully sent the test email and just need to do this from our app.

## Subscribers

In Novu, entities that are supposed to receive notifications are called subscribers. You can see all the subscribers in the ‘subscribers’ tab in the left menu on the Novu web portal. There would be one subscriber by default, which is you. This was created when you signed up for Novu.

In real-world scenarios, the `subscriber id` would be a unique id generated automatically by the database. So for our demo purpose, we’re using a simple subscriber id of ‘1234567890’ in our app.

We’ll first create a subscriber using the following code:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu(<NOVU_API_KEY>);

export async function sendEmail(email, description) {
    await novu.subscribers.identify('1234567890', {
        email: email,
        firstName: "Subscriber",
    });
}

```

Here, we’re creating a subscriber with the subscriber id of `1234567890` and now we’ll send a notification to the subscriber with this very subscriber id by triggering an email notification like follows:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu(<NOVU_API_KEY>);

export async function sendEmail(email, description) {
    await novu.subscribers.identify('1234567890', {
        email: email,
        firstName: "Subscriber",
    });
    await novu.trigger('email-quickstart', {
        to: {
            subscriberId: '1234567890',
            email: email
        },
        payload: {
            email: email,
            description: description
        }
    });
}

```

We’ve exported this function so that we can use this in the route that we’ll now create.

## Create the route and define a function in that route

Now, create a `pages` directory in the root of the project and create a file in it. Give it a name and remember that it will automatically become a route.

In our case, we’re creating a directory called `api` in our pages directory, and inside `api` we’re creating a file called `sub.js`. In this case, our path will be: `http://localhost:3000/api/sub`

In this file, we simply need to define a function that will handle a POST request to our API. It’ll extract the ‘description’ and ‘email’ variables from the ‘request’ body that will be generated every time we make a POST request and call the function to send an email notification with those plugged in.

We’d used these variables in the workflow we had created in the Novu dashboard and also specified the same in the trigger function above.

The function in our route is quite simple and looks like this:

```jsx theme={null}
import { sendEmail } from '@/app/utils/novu';

export default async function subscribe(req, res) {
  try {
    if (req.method === 'POST') {
      const { email, description } = req.body;
      await sendEmail(email, description);
      await res.status(200).json({ message: 'email working' });
    }
  } catch (error) {
    console.log(error);
    res.status(405).json({ message: 'not working' });
  }
}

```

We can now start our local server and test our backend app on Postman. To start the local server, use the following command:

```bash theme={null}
npm run dev

```

Now, open Postman and send a POST request to the route you created earlier. The exact route depends on the file structure you have followed in the pages directory, but in our case, it is - `http://localhost:3000/api/sub`

Also, make sure that in the body, you’re passing the two variables we’re extracting above, namely - email and description, as follows:

<Frame>
  <img />
</Frame>

> In place of [youremail@gmail.com](mailto:youremail@gmail.com), use your actual email and once you send it, you should see the ‘message: email working’ on the bottom as in the image above.

This means that the email notification was sent successfully. Now go to your inbox and you should see an email notification like the following:

<Frame>
  <img />
</Frame>

## Topics

Novu simplifies the process of triggering notifications to multiple subscribers with an API called "Topics". By utilizing the Topics API, you can effortlessly manage bulk notifications easily.

Each topic is uniquely identified by a custom key specified by the user, serving as the primary identifier for interacting with the Topics API.

This intuitive approach streamlines notifications management, empowering users to focus on delivering targeted messages to their subscribers without the hassle of intricate implementation details.

> Make sure that you use a unique key for a Topic. Keys once used, can’t be changed later!

You have the flexibility to assign a descriptive name to a topic. Unlike the topic key, this name does not require uniqueness and can be modified using the provided API.

A topic can have multiple subscribers associated with it. These subscribers will receive notifications whenever a notification is dispatched to the respective topic.

## Create a topic

You can create a topic using two entities - `key` and `name`. Keys are unique identifiers for topics and a name is just something you assign to a topic for convenience.

```jsx theme={null}
import { Novu } from '@novu/node';

export default async function createTopic(req, res) {
  try {
    const novu = new Novu("<NOVU_API_KEY>");
    if (req.method === 'POST') {
      const { key, name } = req.body;
      const result = await novu.topics.create({ key, name });
      res.status(201).json(result.data);
    }
  } catch (error) {
    console.log(error);
    res.status(500).json({ message: error.message });
  }
}

```

This is a simple function that calls the **`create`** method on the **`topics`** property of the \*\*`novu`\*\*instance. This method creates a new topic in the Novu system using the provided **`key`** and **`name`** values.

If you test this on your local machine, you should get something like this:

<Frame>
  <img />
</Frame>

> Note how the return object contains the key I sent from my request body. That signals successful creation!

## Add subscriber to a Topic

The code for adding a subscriber to a previously created topic is as follows:

<Note>
  You can only add those subscribers to a topic that you've already created. You can see all the subscribers in the [Novu web dashboard](https://web.novu.co/subscribers)?utm\_campaign=docs-quick-nextjs
</Note>

```jsx theme={null}
import { Novu } from '@novu/node';

export default async function addSub(req, res) {
  try {
    const novu = new Novu("<NOVU_API_KEY>");
    if (req.method === 'POST') {
      // Get the subscriber ID from the request body
      const subscriberId = req.body.subscriberId;
      // Get the topic key from the request body
      const topicKey = req.body.topicKey;
      // Call Novu SDK to add the subscriber to the topic
      const result = await novu.topics.addSubscribers(topicKey, {
        subscribers: [subscriberId],
      });
      // Return the result as JSON response
      res.status(200).json(result.data);
    }
  } catch (error) {
    console.log(error);
    res.status(500).json({ message: error.message });
  }
}

```

If you see the code above closely, you’ll see that we first establish a connection to Novu using the Novu API key.

Then we extract `subscriberID` and topicKey from the request body and call the **`addSubscribers`** method on the **`topics`** property of the **`novu`** instance, passing the topic key and an object with an array of subscribers.

This adds the subscriber with the `subscriberID` we’d passed to the array of subscribers, which in the above case contains just one subscriber.

If you check this on Postman, the returned array will contain the `subscriberID` that we had passed in the request body, signalling that it was added to the topic successfully.

If, on the other hand, you find the passed `subscriberId` in the `notFound` array inside the `failed` object, it means the subscriber wasn't added to the topic.

You can read more about it [here](https://docs.novu.co/platform/topics/#subscribers-management-in-a-topic).

The image below shows the case where the subscriber has been added successfully:

<Frame>
  <img />
</Frame>

After creating a topic and adding subscribers to the topic, we’ll now proceed to send a notification to all subscribers (we only have one subscriber in our topic though) of a topic. This is what Topics are used for - sending bulk notifications.

## Sending notifications to a topic

Sending notifications to a topic is not a complex task. You need to extract the topic key to which you want to send notifications and trigger Novu’s method on that topic key with the message in the payload:

```jsx theme={null}
import { Novu } from '@novu/node';

export default async function sendNotifToSub(req, res) {
  try {
    const novu = new Novu("<NOVU_API_KEY>");
    if (req.method === 'POST') {
      // Get the topic key from the request body
      const topicKey = req.body.topicKey;
      const email = req.body.email;
      const description = req.body.description;

      // Call Novu SDK to trigger a notification to the topic subscribers
      const result = await novu.trigger('email-quickstart', {
        to: [{ type: 'Topic', topicKey: topicKey }],
        payload: {
          email: email,
          description: description,
        },
      });
      // Return the result as JSON response
      res.json(result.data);
    }
  } catch (error) {
    console.log(error);
    res.status(500).json({ message: error.message });
  }
}

```

Testing this on Postman should give you something like this:

<Frame>
  <img />
</Frame>

If you see this, then it means the notification was sent successfully, as can be seen in my inbox down below:

<Frame>
  <img />
</Frame>

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, and workflow, configured a channel provider, triggered a single notification, and sent an email notification.


# NodeJS quickstart
Source: https://v0.x-docs.novu.co/quickstarts/nodejs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Node.js.

Welcome to the Node.js Quickstart guide for Novu, a powerful notification service that enables you to send multi-channel (SMS, Email, Chat, Push) notifications from your Node.js applications. In this Quickstart, you'll learn how to seamlessly integrate Novu into your app and perform various essential tasks. Let's get started!

## Prerequisites

Before diving into the Quickstart, make sure you have the following:

* Node.js installed on your development machine.
* A Novu account. If you don't have one, sign up for free at [the web dashboard](https://web.novu.co/?utm_campaign=docs-quick-nodejs)

You can also [view the completed code](https://github.com/novuhq/nodejs-sdk-quickstart) of this quick start in a GitHub repo.

## Install and Set Up Novu in your Node.js App

First, you must install the Novu package in your Node.js application. Open your terminal and run the following command:

```bash theme={null}
npm install @novu/node

```

Once installed, you can import Novu into your app and initialize it using your Novu account credentials. This step establishes a connection between your app and the Novu notification service.

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');
```

Replace the `<NOVU_API_KEY>` value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-nodejs).

🔑 Note: Please do not hardcode your credentials in a file in production. Use environment variables instead.

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-nodejs) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favorite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Workflow

A workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Note: Proper authorization needs to be set for the Chat channel for subscribers.

Please proceed to create a workflow.

1. Click “Workflows” on the left sidebar of your Novu dashboard.
2. Click the “Create Workflow” button on the top right.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select "Email" as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

6. Click on the “Test” tab and send a test email to verify your workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. Yaaay, you have successfully sent your first notification via the Novu dashboard! Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click “Subscribers” on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```jsx theme={null}
// Create a subscriber
const subscriberId = '7789'; // Replace this with a unique user ID that matches your database.
await novu.subscribers.identify(subscriberId, {
  email: 'abc@gmail.com', // optional
  firstName: 'John', // optional
  lastName: 'Doe', // optional
  phone: '', // optional
  avatar: '', // optional
  locale: '', // optional
  data: { customKey1: 'customVal1', customKey2: 'customVal2' }, // optional
});
```

Run the code in your terminal like so:

```bash theme={null}
node index.js

```

You should see the subscriber on your Novu dashboard.

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `updateSubscriber` method like so:

```jsx theme={null}
// Update subscriber detail
await novu.subscribers.update('7789', {
  // new email
  email: 'validemail@gmail.com', // optional
  // new phone
  phone: '+19874567832', // optional
});
```

Other valid fields that can be updated are `phone`, `avatar`, and `data` . The `data` field can accept an array of metadata that you want to attach to the subscriber.

Note: To make all of your app users subscribers, you need to programmatically add them to Novu.

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```jsx theme={null}
const notificationWorkflowId = 'first-email';

novu.trigger(notificationWorkflowId, {
  to: {
    subscriberId: '7789',
  },
  payload: {},
});
```

Before running the code, make sure you understand the following:

* The value of `notificationWorkflowId` should be the workflow's trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriber ID.

Run the code to trigger a notification!

```bash theme={null}
node index.js

```

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called "Topics" and allows users to manage their bulk notifications without having to implement complex loops. A topic is identified by a custom key that is provided by the user, and this key will be the identifier used in the Topics API.

⚠️ DANGER: The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.

Users can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed using the API.

A topic can have different subscribers, who will receive a notification whenever a notification is sent to the topic.

## Create a topic

Copy and paste the following code into your app to create a topic:

```jsx theme={null}
const result = await novu.topics.create({
  key: 'unique-topic-identifier',
  name: 'descriptive-topic-name',
});
```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add Subscribers To A Topic

Copy and paste the following code into your app to add subscribers to a topic.

```jsx theme={null}
const topicKey = '<YOUR TOPIC KEY>';

const response = await novu.topics.addSubscribers(topicKey, {
  subscribers: ['subscriber-id-1', 'subscriber-id-2', ...],
});
```

* To add multiple subscribers to a topic, simply separate their names with commas and add them to the array as part of the `subscribers` value.

## Send Notification To A Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, use Novu's API as follows:

```jsx theme={null}
const topicKey = '<TOPIC_KEY>';
const notificationTemplateId = '<WORKFLOW_TRIGGER_IDENTIFIER>';

await novu.trigger(notificationTemplateId, {
  to: [{ type: 'Topic', topicKey: topicKey }],
  payload: {},
});
```

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider, triggered a single notification, created a topic, added a subscriber to a topic and even triggered a notification to a topic in your application.


# Quickstarts
Source: https://v0.x-docs.novu.co/quickstarts/overview

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with any language/framework of your choice.

<CardGroup>
  <Card title="Vue" icon="vuejs" href="/quickstarts/vue">
    Embed a real-time notification center component in your Vue application.
  </Card>

  <Card title="React" icon="react" href="/quickstarts/react">
    Embed a real-time notification center component in your React application.
  </Card>

  <Card title="Angular" icon="angular" href="/quickstarts/angular">
    Embed a real-time notification center component in your Angular application.
  </Card>

  <Card title="VanillaJS" icon="js" href="/quickstarts/vanillajs">
    Embed a real-time notification center component in your VanillaJS
    application.
  </Card>

  <Card
    title="RedwoodJS"
    icon={
  <svg
    xmlns="http://www.w3.org/2000/svg"
    width="25"
    height="23"
    viewBox="0 0 256 277"
  >
    <path
      fill="#FFF"
      d="M112.39 3.928C101.983 9.164 80.046 19.36 68.16 27.493c-11.885 8.134-10.407 15.711-15.61 20.948c-5.203 5.237-20.814 18.329-31.22 26.184c-10.407 7.855-7.806 28.803-10.407 36.658c-2.602 7.855-7.806 26.184-10.407 34.04c-2.602 7.855 5.203 18.329 10.407 28.802c5.203 10.474 18.211 39.277 23.415 49.75c5.203 10.474 20.813 5.237 33.822 15.71c13.009 10.475 31.22 23.568 44.229 31.423c13.008 7.855 18.212 7.855 31.22 0c13.009-7.855 31.22-20.948 44.23-31.422c13.008-10.474 28.618-5.237 33.822-15.71c5.203-10.474 18.211-39.277 23.415-49.75c5.203-10.474 13.008-20.948 10.406-28.803c-2.602-7.856-7.804-26.185-10.406-34.04c-2.602-7.855 0-28.803-10.407-36.658s-22.487-17.857-31.22-26.184c-8.734-8.327-5.204-13.092-15.61-20.948c-10.407-7.855-33.823-18.329-44.23-23.565c-10.406-5.237-20.813-5.237-31.22 0Z"
    />
    <path
      fill="#BF4722"
      d="m75.644 49.319l48.694 33.238a6.886 6.886 0 0 0 3.7 1.155a6.665 6.665 0 0 0 3.7-1.155l48.73-33.35a6.65 6.65 0 0 0 2.748-5.947a6.633 6.633 0 0 0-3.672-5.418L130.85 13.733a6.692 6.692 0 0 0-5.846 0l-48.546 24.11a6.633 6.633 0 0 0-3.707 5.5a6.649 6.649 0 0 0 2.893 5.976Zm68.933 43.671a6.721 6.721 0 0 0 2.886 5.515l39.037 26.68a6.55 6.55 0 0 0 8.103-.522l32.746-29.288a6.654 6.654 0 0 0 2.213-5.156a6.648 6.648 0 0 0-2.509-5.017L195.787 60.2a6.623 6.623 0 0 0-7.844-.298l-40.48 27.686a6.72 6.72 0 0 0-2.886 5.403Zm-97.09 36.293a6.696 6.696 0 0 1 2.182 5.627a6.524 6.524 0 0 1-3.293 5.068l-23.31 13.973a6.586 6.586 0 0 1-7.5-.512a6.698 6.698 0 0 1-2.195-7.238l8.621-27.127a6.607 6.607 0 0 1 4.551-4.397a6.406 6.406 0 0 1 6.143 1.453l14.8 13.153Zm126.432 2.832l-42.144-28.84a6.622 6.622 0 0 0-7.4 0l-42.145 28.84a6.754 6.754 0 0 0-2.886 5.068a6.88 6.88 0 0 0 2.22 5.44l42.108 37.672a6.597 6.597 0 0 0 4.403 1.677a6.63 6.63 0 0 0 4.403-1.677l42.107-37.672a6.73 6.73 0 0 0 2.183-5.44a6.606 6.606 0 0 0-2.849-5.068Zm-112.41-7.452L28.802 95.375a6.804 6.804 0 0 1-2.22-5.254a6.574 6.574 0 0 1 2.478-5.03l31.266-25.152a6.696 6.696 0 0 1 7.882-.298l40.442 27.685a6.682 6.682 0 0 1 3.01 5.59a6.682 6.682 0 0 1-3.01 5.589l-39 26.68a6.624 6.624 0 0 1-8.14-.522Zm167.95 42.069l-33.302-19.935a6.55 6.55 0 0 0-7.77.745l-40.702 36.33a6.696 6.696 0 0 0-2.13 6.13a6.66 6.66 0 0 0 4.055 5.05l56.463 22.878a6.333 6.333 0 0 0 2.442.485c2.621.008 5-1.54 6.069-3.95l17.501-39.2c1.425-3.102.29-6.787-2.627-8.533Zm4.624-47.658l8.622 27.127h-.074a6.71 6.71 0 0 1-.975 5.958a6.61 6.61 0 0 1-5.353 2.724a6.478 6.478 0 0 1-3.367-.932l-23.348-13.973a6.489 6.489 0 0 1-3.182-5.068a6.62 6.62 0 0 1 2.183-5.627l14.8-13.19a6.59 6.59 0 0 1 6.143-1.454a6.72 6.72 0 0 1 4.551 4.435Zm-123.51 70.91a6.66 6.66 0 0 0-2.109-6.111l-40.701-36.331a6.55 6.55 0 0 0-7.77-.745L26.69 166.732c-2.883 1.754-4.024 5.392-2.664 8.496l17.539 39.2c1.453 3.268 5.21 4.798 8.51 3.465l56.427-22.88a6.659 6.659 0 0 0 4.07-5.03Zm19.98 11.178l45.29 18.333a6.665 6.665 0 0 1 3.997 5.44a6.614 6.614 0 0 1-2.813 6.223l-45.326 31.488a6.551 6.551 0 0 1-3.7 1.191a6.682 6.682 0 0 1-3.7-1.191l-45.29-31.488a6.651 6.651 0 0 1-2.849-6.222a6.775 6.775 0 0 1 4.144-5.44l45.29-18.334a6.69 6.69 0 0 1 4.958 0Z"
    />
  </svg>
}
    href="/quickstarts/redwoodjs"
  >
    Embed a real-time notification center component in your RedwoodJS
    application.
  </Card>

  <Card title="iFrame" icon="html5" href="/quickstarts/iFrame">
    Embed a real-time notification center component in your iFrame application.
  </Card>

  <Card title="Node.js" icon="node" href="/quickstarts/nodejs">
    Connect a Node.js application to Novu.
  </Card>

  <Card
    title="PHP"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#deviconPhp0)" d="M0 64c0 18.593 28.654 33.667 64 33.667c35.346 0 64-15.074 64-33.667c0-18.593-28.655-33.667-64-33.667C28.654 30.333 0 45.407 0 64Z"/><path fill="#777bb3" d="M64 95.167c33.965 0 61.5-13.955 61.5-31.167c0-17.214-27.535-31.167-61.5-31.167S2.5 46.786 2.5 64c0 17.212 27.535 31.167 61.5 31.167Z"/><path d="M34.772 67.864c2.793 0 4.877-.515 6.196-1.53c1.306-1.006 2.207-2.747 2.68-5.175c.44-2.27.272-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.464l-2.473 12.732zM20.173 83.547a.694.694 0 0 1-.68-.828l6.557-33.738a.695.695 0 0 1 .68-.561h14.134c4.442 0 7.748 1.206 9.827 3.585c2.088 2.39 2.734 5.734 1.917 9.935c-.333 1.711-.905 3.3-1.7 4.724a15.818 15.818 0 0 1-3.128 3.92c-1.531 1.432-3.264 2.472-5.147 3.083c-1.852.604-4.232.91-7.07.91h-5.724l-1.634 8.408a.695.695 0 0 1-.682.562z"/><path fill="#fff" d="M34.19 55.826h3.891c3.107 0 4.186.682 4.553 1.089c.607.674.723 2.097.331 4.112c-.439 2.257-1.253 3.858-2.42 4.756c-1.194.92-3.138 1.386-5.773 1.386h-2.786l2.205-11.342zm6.674-8.1H26.731a1.39 1.39 0 0 0-1.364 1.123L18.81 82.588a1.39 1.39 0 0 0 1.363 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.151c2.912 0 5.364-.318 7.287-.944c1.977-.642 3.796-1.731 5.406-3.237a16.522 16.522 0 0 0 3.259-4.087c.831-1.487 1.429-3.147 1.775-4.931c.86-4.423.161-7.964-2.076-10.524c-2.216-2.537-5.698-3.823-10.349-3.823zM30.301 68.557h4.471c2.963 0 5.17-.557 6.62-1.675c1.451-1.116 2.428-2.98 2.938-5.591c.485-2.508.264-4.277-.665-5.308c-.931-1.03-2.791-1.546-5.584-1.546h-5.036l-2.743 14.12m10.563-19.445c4.252 0 7.353 1.117 9.303 3.348c1.95 2.232 2.536 5.347 1.76 9.346c-.322 1.648-.863 3.154-1.625 4.518c-.764 1.366-1.76 2.614-2.991 3.747c-1.468 1.373-3.097 2.352-4.892 2.935c-1.794.584-4.08.875-6.857.875h-6.296l-1.743 8.97h-7.35l6.558-33.739h14.133"/><path d="M69.459 74.577a.694.694 0 0 1-.682-.827l2.9-14.928c.277-1.42.209-2.438-.19-2.87c-.245-.263-.979-.704-3.15-.704h-5.256l-3.646 18.768a.695.695 0 0 1-.683.56h-7.29a.695.695 0 0 1-.683-.826l6.558-33.739a.695.695 0 0 1 .682-.561h7.29a.695.695 0 0 1 .683.826L64.41 48.42h5.653c4.307 0 7.227.758 8.928 2.321c1.733 1.593 2.275 4.14 1.608 7.573l-3.051 15.702a.695.695 0 0 1-.682.56h-7.407z"/><path fill="#fff" d="M65.31 38.755h-7.291a1.39 1.39 0 0 0-1.364 1.124l-6.557 33.738a1.39 1.39 0 0 0 1.363 1.654h7.291a1.39 1.39 0 0 0 1.364-1.124l3.537-18.205h4.682c2.168 0 2.624.463 2.641.484c.132.14.305.795.019 2.264l-2.9 14.927a1.39 1.39 0 0 0 1.364 1.654h7.408a1.39 1.39 0 0 0 1.363-1.124l3.051-15.7c.715-3.686.103-6.45-1.82-8.217c-1.836-1.686-4.91-2.505-9.398-2.505h-4.81l1.421-7.315a1.39 1.39 0 0 0-1.364-1.655zm0 1.39l-1.743 8.968h6.496c4.087 0 6.907.714 8.457 2.14c1.553 1.426 2.017 3.735 1.398 6.93l-3.052 15.699h-7.407l2.901-14.928c.33-1.698.208-2.856-.365-3.474c-.573-.617-1.793-.926-3.658-.926h-5.829l-3.756 19.327H51.46l6.558-33.739h7.292z"/><path d="M92.136 67.864c2.793 0 4.878-.515 6.198-1.53c1.304-1.006 2.206-2.747 2.679-5.175c.44-2.27.273-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.463l-2.475 12.732zM77.54 83.547a.694.694 0 0 1-.682-.828l6.557-33.738a.695.695 0 0 1 .682-.561H98.23c4.442 0 7.748 1.206 9.826 3.585c2.089 2.39 2.734 5.734 1.917 9.935a15.878 15.878 0 0 1-1.699 4.724a15.838 15.838 0 0 1-3.128 3.92c-1.53 1.432-3.265 2.472-5.147 3.083c-1.852.604-4.232.91-7.071.91h-5.723l-1.633 8.408a.695.695 0 0 1-.683.562z"/><path fill="#fff" d="M91.555 55.826h3.891c3.107 0 4.186.682 4.552 1.089c.61.674.724 2.097.333 4.112c-.44 2.257-1.254 3.858-2.421 4.756c-1.195.92-3.139 1.386-5.773 1.386h-2.786l2.204-11.342zm6.674-8.1H84.096a1.39 1.39 0 0 0-1.363 1.123l-6.558 33.739a1.39 1.39 0 0 0 1.364 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.15c2.911 0 5.364-.318 7.286-.944c1.978-.642 3.797-1.731 5.408-3.238a16.52 16.52 0 0 0 3.258-4.086c.832-1.487 1.428-3.147 1.775-4.931c.86-4.423.162-7.964-2.076-10.524c-2.216-2.537-5.697-3.823-10.35-3.823zM87.666 68.557h4.47c2.964 0 5.17-.557 6.622-1.675c1.45-1.116 2.428-2.98 2.936-5.591c.487-2.508.266-4.277-.665-5.308c-.93-1.03-2.791-1.546-5.583-1.546h-5.035Zm10.563-19.445c4.251 0 7.354 1.117 9.303 3.348c1.95 2.232 2.537 5.347 1.759 9.346c-.32 1.648-.862 3.154-1.624 4.518c-.763 1.366-1.76 2.614-2.992 3.747c-1.467 1.373-3.097 2.352-4.892 2.935c-1.793.584-4.078.875-6.856.875h-6.295l-1.745 8.97h-7.35l6.558-33.739h14.133"/><defs><radialGradient id="deviconPhp0" cx="0" cy="0" r="1" gradientTransform="translate(38.426 42.169) scale(84.04136)" gradientUnits="userSpaceOnUse"><stop stopColor="#AEB2D5"/><stop offset=".3" stopColor="#AEB2D5"/><stop offset=".75" stopColor="#484C89"/><stop offset="1" stopColor="#484C89"/></radialGradient></defs></svg>
}
    href="/quickstarts/php"
  >
    Connect a PHP application to Novu.
  </Card>

  <Card
    title="Python"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="34.87" viewBox="0 0 256 255"><defs><linearGradient id="logosPython0" x1="12.959%" x2="79.639%" y1="12.039%" y2="78.201%"><stop offset="0%" stopColor="#387EB8"/><stop offset="100%" stopColor="#366994"/></linearGradient><linearGradient id="logosPython1" x1="19.128%" x2="90.742%" y1="20.579%" y2="88.429%"><stop offset="0%" stopColor="#FFE052"/><stop offset="100%" stopColor="#FFC331"/></linearGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosPython0)" d="M126.916.072c-64.832 0-60.784 28.115-60.784 28.115l.072 29.128h61.868v8.745H41.631S.145 61.355.145 126.77c0 65.417 36.21 63.097 36.21 63.097h21.61v-30.356s-1.165-36.21 35.632-36.21h61.362s34.475.557 34.475-33.319V33.97S194.67.072 126.916.072ZM92.802 19.66a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.13Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosPython1)" d="M128.757 254.126c64.832 0 60.784-28.115 60.784-28.115l-.072-29.127H127.6v-8.745h86.441s41.486 4.705 41.486-60.712c0-65.416-36.21-63.096-36.21-63.096h-21.61v30.355s1.165 36.21-35.632 36.21h-61.362s-34.475-.557-34.475 33.32v56.013s-5.235 33.897 62.518 33.897Zm34.114-19.586a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.131a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13Z"/></svg>
}
    href="/quickstarts/python"
  >
    Connect a Python application to Novu.
  </Card>

  <Card
    title="Kotlin"
    icon={
  <svg
    xmlns="http://www.w3.org/2000/svg"
    width="20"
    height="20"
    viewBox="0 0 256 256"
  >
    <defs>
      <linearGradient
        id="logosKotlinIcon0"
        x1="99.991%"
        x2=".01%"
        y1="-.011%"
        y2="100.01%"
      >
        <stop offset=".344%" stopColor="#E44857" />
        <stop offset="46.89%" stopColor="#C711E1" />
        <stop offset="100%" stopColor="#7F52FF" />
      </linearGradient>
    </defs>
    <path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosKotlinIcon0)" d="M256 256H0V0h256L128 127.949z" />
  </svg>
}
    href="/quickstarts/kotlin"
  >
    Connect a Kotlin application to Novu.
  </Card>

  <Card
    title="Ruby"
    icon={
  <svg xmlns="http://www.w3.org/2000/svg" width="20" height="19.93" viewBox="0 0 256 255"><defs><linearGradient id="logosRuby0" x1="84.75%" x2="58.254%" y1="111.399%" y2="64.584%"><stop offset="0%" stopColor="#FB7655"/><stop offset="0%" stopColor="#FB7655"/><stop offset="41%" stopColor="#E42B1E"/><stop offset="99%" stopColor="#900"/><stop offset="100%" stopColor="#900"/></linearGradient><linearGradient id="logosRuby1" x1="116.651%" x2="1.746%" y1="60.89%" y2="19.288%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby2" x1="75.774%" x2="38.978%" y1="219.327%" y2="7.829%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby3" x1="50.012%" x2="66.483%" y1="7.234%" y2="79.135%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E57252"/><stop offset="46%" stopColor="#DE3B20"/><stop offset="99%" stopColor="#A60003"/><stop offset="100%" stopColor="#A60003"/></linearGradient><linearGradient id="logosRuby4" x1="46.174%" x2="49.932%" y1="16.348%" y2="83.047%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E4714E"/><stop offset="56%" stopColor="#BE1A0D"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby5" x1="36.965%" x2="49.528%" y1="15.594%" y2="92.478%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="18%" stopColor="#E46342"/><stop offset="40%" stopColor="#C82410"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby6" x1="13.609%" x2="85.764%" y1="58.346%" y2="-46.717%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="54%" stopColor="#C81F11"/><stop offset="99%" stopColor="#BF0905"/><stop offset="100%" stopColor="#BF0905"/></linearGradient><linearGradient id="logosRuby7" x1="27.624%" x2="50.745%" y1="21.135%" y2="79.056%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="31%" stopColor="#DE4024"/><stop offset="99%" stopColor="#BF190B"/><stop offset="100%" stopColor="#BF190B"/></linearGradient><linearGradient id="logosRuby8" x1="-20.667%" x2="104.242%" y1="122.282%" y2="-6.342%"><stop offset="0%" stopColor="#BD0012"/><stop offset="0%" stopColor="#BD0012"/><stop offset="7%" stopColor="#FFF"/><stop offset="17%" stopColor="#FFF"/><stop offset="27%" stopColor="#C82F1C"/><stop offset="33%" stopColor="#820C01"/><stop offset="46%" stopColor="#A31601"/><stop offset="72%" stopColor="#B31301"/><stop offset="99%" stopColor="#E82609"/><stop offset="100%" stopColor="#E82609"/></linearGradient><linearGradient id="logosRuby9" x1="58.792%" x2="11.964%" y1="65.205%" y2="50.128%"><stop offset="0%" stopColor="#8C0C01"/><stop offset="0%" stopColor="#8C0C01"/><stop offset="54%" stopColor="#990C00"/><stop offset="99%" stopColor="#A80D0E"/><stop offset="100%" stopColor="#A80D0E"/></linearGradient><linearGradient id="logosRubya" x1="79.319%" x2="23.088%" y1="62.754%" y2="17.888%"><stop offset="0%" stopColor="#7E110B"/><stop offset="0%" stopColor="#7E110B"/><stop offset="99%" stopColor="#9E0C00"/><stop offset="100%" stopColor="#9E0C00"/></linearGradient><linearGradient id="logosRubyb" x1="92.88%" x2="59.841%" y1="74.122%" y2="39.704%"><stop offset="0%" stopColor="#79130D"/><stop offset="0%" stopColor="#79130D"/><stop offset="99%" stopColor="#9E120B"/><stop offset="100%" stopColor="#9E120B"/></linearGradient><linearGradient id="logosRubyc" x1="56.57%" x2="3.105%" y1="101.717%" y2="11.993%"><stop offset="0%" stopColor="#8B2114"/><stop offset="0%" stopColor="#8B2114"/><stop offset="43%" stopColor="#9E100A"/><stop offset="99%" stopColor="#B3100C"/><stop offset="100%" stopColor="#B3100C"/></linearGradient><linearGradient id="logosRubyd" x1="30.87%" x2="92.471%" y1="35.599%" y2="100.694%"><stop offset="0%" stopColor="#B31000"/><stop offset="0%" stopColor="#B31000"/><stop offset="44%" stopColor="#910F08"/><stop offset="99%" stopColor="#791C12"/><stop offset="100%" stopColor="#791C12"/></linearGradient><radialGradient id="logosRubye" cx="32.001%" cy="40.21%" r="69.573%" fx="32.001%" fy="40.21%"><stop offset="0%" stopColor="#A80D00"/><stop offset="0%" stopColor="#A80D00"/><stop offset="99%" stopColor="#7E0E08"/><stop offset="100%" stopColor="#7E0E08"/></radialGradient><radialGradient id="logosRubyf" cx="13.549%" cy="40.86%" r="88.386%" fx="13.549%" fy="40.86%"><stop offset="0%" stopColor="#A30C00"/><stop offset="0%" stopColor="#A30C00"/><stop offset="99%" stopColor="#800E08"/><stop offset="100%" stopColor="#800E08"/></radialGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby0)" d="m197.467 167.764l-145.52 86.41l188.422-12.787L254.88 51.393l-57.414 116.37Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby1)" d="M240.677 241.257L224.482 129.48l-44.113 58.25l60.308 53.528Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby2)" d="m240.896 241.257l-118.646-9.313l-69.674 21.986l188.32-12.673Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby3)" d="m52.744 253.955l29.64-97.1L17.16 170.8l35.583 83.154Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby4)" d="M180.358 188.05L153.085 81.226l-78.047 73.16l105.32 33.666Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby5)" d="m248.693 82.73l-73.777-60.256l-20.544 66.418l94.321-6.162Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby6)" d="M214.191.99L170.8 24.97L143.424.669l70.767.322Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby7)" d="m0 203.372l18.177-33.151l-14.704-39.494L0 203.372Z"/><path fill="#FFF" d="m2.496 129.48l14.794 41.963l64.283-14.422l73.39-68.207l20.712-65.787L143.063 0L87.618 20.75c-17.469 16.248-51.366 48.396-52.588 49c-1.21.618-22.384 40.639-32.534 59.73Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby8)" d="M54.442 54.094c37.86-37.538 86.667-59.716 105.397-40.818c18.72 18.898-1.132 64.823-38.992 102.349c-37.86 37.525-86.062 60.925-104.78 42.027c-18.73-18.885.515-66.032 38.375-103.558Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby9)" d="m52.744 253.916l29.408-97.409l97.665 31.376c-35.312 33.113-74.587 61.106-127.073 66.033Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubya)" d="m155.092 88.622l25.073 99.313c29.498-31.016 55.972-64.36 68.938-105.603l-94.01 6.29Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyb)" d="M248.847 82.833c10.035-30.282 12.35-73.725-34.966-81.791l-38.825 21.445l73.791 60.346Z"/><path fill="#9E1209" d="M0 202.935c1.39 49.979 37.448 50.724 52.808 51.162l-35.48-82.86L0 202.935Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubye)" d="M155.232 88.777c22.667 13.932 68.35 41.912 69.276 42.426c1.44.81 19.695-30.784 23.838-48.64l-93.114 6.214Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyf)" d="m82.113 156.507l39.313 75.848c23.246-12.607 41.45-27.967 58.121-44.42l-97.434-31.428Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyc)" d="m17.174 171.34l-5.57 66.328c10.51 14.357 24.97 15.605 40.136 14.486c-10.973-27.311-32.894-81.92-34.566-80.814Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyd)" d="m174.826 22.654l78.1 10.96c-4.169-17.662-16.969-29.06-38.787-32.623l-39.313 21.663Z"/></svg>

}
    href="/quickstarts/ruby"
  >
    Connect a Ruby application to Novu.
  </Card>

  <Card
    title=".NET"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 256 256"><g fill="none"><rect width="256" height="256" fill="#512BD4" rx="60"/><path fill="#fff" d="M24.052 168.943c-2.236 0-4.138-.731-5.703-2.194c-1.566-1.501-2.349-3.283-2.349-5.347c0-2.101.783-3.902 2.349-5.403c1.565-1.5 3.466-2.251 5.703-2.251c2.274 0 4.194.751 5.76 2.251c1.603 1.501 2.404 3.302 2.404 5.403c0 2.064-.801 3.846-2.404 5.347c-1.566 1.463-3.486 2.194-5.76 2.194Zm89.415-1.238H98.929l-38.304-59.318a26.371 26.371 0 0 1-2.404-4.672h-.336c.298 1.726.447 5.422.447 11.087v52.903H45.471V87H60.96l37.018 57.912c1.566 2.402 2.572 4.052 3.02 4.953h.223c-.372-2.139-.559-5.759-.559-10.863V87h12.805v80.705Zm62.631 0h-45.014V87h43.225v11.369h-29.916v22.849h27.568v11.312h-27.568v23.863h31.705v11.312Zm63.973-69.336h-23.038v69.336h-13.309V98.369h-22.982V87h59.329v11.369Z"/></g></svg>
}
    href="/quickstarts/.NET"
  >
    Connect a .NET application to Novu.
  </Card>

  <Card
    title="NextJS"
    icon={
  <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 128 128"><path d="M64 0C28.7 0 0 28.7 0 64s28.7 64 64 64c11.2 0 21.7-2.9 30.8-7.9L48.4 55.3v36.6h-6.8V41.8h6.8l50.5 75.8C116.4 106.2 128 86.5 128 64c0-35.3-28.7-64-64-64zm22.1 84.6l-7.5-11.3V41.8h7.5v42.8z"/></svg>
}
    href="/quickstarts/nextjs"
  >
    Connect a NextJS application to Novu.
  </Card>

  <Card title="Go" icon="golang" href="/quickstarts/go">
    Connect a Go application to Novu.
  </Card>

  <Card
    title="Java"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="#0074BD" d="M47.617 98.12s-4.767 2.774 3.397 3.71c9.892 1.13 14.947.968 25.845-1.092c0 0 2.871 1.795 6.873 3.351c-24.439 10.47-55.308-.607-36.115-5.969zm-2.988-13.665s-5.348 3.959 2.823 4.805c10.567 1.091 18.91 1.18 33.354-1.6c0 0 1.993 2.025 5.132 3.131c-29.542 8.64-62.446.68-41.309-6.336z"/><path fill="#EA2D2E" d="M69.802 61.271c6.025 6.935-1.58 13.17-1.58 13.17s15.289-7.891 8.269-17.777c-6.559-9.215-11.587-13.792 15.635-29.58c0 .001-42.731 10.67-22.324 34.187z"/><path fill="#0074BD" d="M102.123 108.229s3.529 2.91-3.888 5.159c-14.102 4.272-58.706 5.56-71.094.171c-4.451-1.938 3.899-4.625 6.526-5.192c2.739-.593 4.303-.485 4.303-.485c-4.953-3.487-32.013 6.85-13.743 9.815c49.821 8.076 90.817-3.637 77.896-9.468zM49.912 70.294s-22.686 5.389-8.033 7.348c6.188.828 18.518.638 30.011-.326c9.39-.789 18.813-2.474 18.813-2.474s-3.308 1.419-5.704 3.053c-23.042 6.061-67.544 3.238-54.731-2.958c10.832-5.239 19.644-4.643 19.644-4.643zm40.697 22.747c23.421-12.167 12.591-23.86 5.032-22.285c-1.848.385-2.677.72-2.677.72s.688-1.079 2-1.543c14.953-5.255 26.451 15.503-4.823 23.725c0-.002.359-.327.468-.617z"/><path fill="#EA2D2E" d="M76.491 1.587S89.459 14.563 64.188 34.51c-20.266 16.006-4.621 25.13-.007 35.559c-11.831-10.673-20.509-20.07-14.688-28.815C58.041 28.42 81.722 22.195 76.491 1.587z"/><path fill="#0074BD" d="M52.214 126.021c22.476 1.437 57-.8 57.817-11.436c0 0-1.571 4.032-18.577 7.231c-19.186 3.612-42.854 3.191-56.887.874c0 .001 2.875 2.381 17.647 3.331z"/></svg>
}
    href="/quickstarts/java"
  >
    Connect a Java application to Novu.
  </Card>
</CardGroup>


# PHP quickstart
Source: https://v0.x-docs.novu.co/quickstarts/php

Use Novu to send multi-channel (SMS, Email, Chat, Push) notifications from a PHP app.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications from a PHP app.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-php) if you don’t have one yet.
* A working PHP development environment with a PHP version of 7.2+.

You can also [v](https://cloudinary.com/documentation/php_quickstart#view_the_completed_code)[iew the completed code](https://github.com/novuhq/novu-php-quickstart) of this quick start in a GitHub repo.

## Install Novu PHP SDK

The [PHP SDK](http://github.com/novuhq/novu-php) provides a fluent and expressive interface for interacting with Novu's API and managing notifications.

Now install the Novu PHP SDK by running the following command in your terminal:

```bash theme={null}
composer require unicodeveloper/novu

```

Otherwise, create a file named `composer.json` and add the following to it:

```php theme={null}
{
    "require": {
        "unicodeveloper/novu": "^1.0"
    }
}

```

Next, install the SDK by running the following `composer` command:

```bash theme={null}
composer install

```

## Initialize & Configure the Novu SDK

Create a new file, `index.php` in your application and add the following code to it:

```php theme={null}
<?php

  require('vendor/autoload.php');

  use Novu\SDK\Novu;

$apiKey = '<NOVU_API_KEY>';
$novu = new Novu($apiKey);
```

Replace the `$apiKey`’s value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-php).

<Note>
  Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-php) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favourite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create A Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **Untitled.** Rename it to a more suitable title.
4. Select **Email** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

6. Click on the “Test” tab and send a test email to verify your workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. Yaaay, you have successfully sent your first notification via the Novu dashboard! Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click “Subscribers” on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```php theme={null}
// Create subscriber
$novu->createSubscriber([
    'subscriberId' => '7789', // replace with system_internal_user_id
    'email' => 'abc@gmail.com',
    'firstName' => 'John', // optional
    'lastName' => 'Doe', // optional
])->toArray();
```

Run the code in your terminal like so:

```bash theme={null}
php index.php

```

You should see the subscriber on your Novu dashboard.

<Frame>
  <img />
</Frame>

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `updateSubscriber` method like so:

```php theme={null}
// Update subscriber detail
$subscriberId = '7789';
$novu->updateSubscriber($subscriberId, [
    'email' => 'validemail@gmail.com',  // replace with valid email
    'firstName' => '<insert-firstname>', // optional
    'lastName' => '<insert-lastname>', // optional
])->toArray();
```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an array of metadata that you want to attach to the subscriber.

<Note>
  To make all of your app users subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```php theme={null}
$novu->triggerEvent([
    'name' => 'first-email',
    'payload' => ['first-name' => 'Adam'],
    'to' => [
        'subscriberId' => '7789'
    ]
])->toArray();
```

Before running the code, make sure you understand the following:

* The value of `name` should be the workflow’s trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriber ID.

Run the code to trigger a notification!

```php theme={null}
php index.php

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safeguards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```php theme={null}
// Create a Topic
$novu->createTopic([
  'key'  => 'frontend-users',
  'name' => 'All frontend users'
]);
```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers to a topic:

```php theme={null}
$topicKey = 'frontend-users';
$subscribers = [
    '6460925ce1a93324257d2fc1',
    '7789'
];

// Add subscribers to a topic
$novu->topic($topicKey)->addSubscribers($subscribers);
```

On the other hand, if you want to remove subscribers from a topic, do the following:

```php theme={null}
$topicKey = 'frontend-users';
$subscribers = [
    '6460925ce1a93324257d2fc1',
    '7789'
];

// Remove subscribers from a topic
$novu->topic($topicKey)->removeSubscribers($subscribers);
```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```php theme={null}
// Send notifications to a topic (all frontend users)
$novu->triggerEvent([
    'name' => 'first-email',
    'to' => [
       [
         'type' => 'Topic',
         'topicKey' => 'frontend-users'
       ]
    ]
])->toArray();
```

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider and triggered a notification in your application.


# Python quickstart
Source: https://v0.x-docs.novu.co/quickstarts/python

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Python.

In this guide, you'll learn how to use Novu in a Python application. Let's see how you can seamlessly integrate Novu into your Python project!

## Prerequisites

Before diving into the Quickstart, make sure you have the following:

* Python3 installed on your development machine.
* A Novu account. If you don't have one, sign up for free at [web.novu.co](https://web.novu.co?utm_campaign=docs-gs-quick-python)

## Install and Set Up Novu in your Python Project

First, you must install the Novu package in your Python project. From your terminal, you can install the Novu package in your project by running either of the following two commands:

Via pip

```bash theme={null}
pip install novu

```

Via poetry

```bash theme={null}
poetry add novu

```

Once installed, you can import Novu into your project and initialize it using your Novu account credentials. This step establishes a connection between your app and the Novu notification service.

```python theme={null}
from novu.config import NovuConfig

NovuConfig().configure("https://api.novu.co", "<NOVU_API_KEY>")

```

Replace the `<NOVU_API_KEY>` value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-python).

<Note>Please do not hardcode your credentials in a file in production. Use environment variables instead.</Note>

## Set Up A Channel Provider

A channel provider is a service that lets you use one or more notification channels such as sending an email, SMS, push notification etc. Our integration store currently supports four channels: Email, SMS, Chat, and Push. Each of these channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel** at a time. Connect anyone of your preferred providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Notification Workflow

A notification workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber.

The workflow includes the following:

* Notification workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>Proper authorization needs to be set for the Chat channel for subscribers.</Note>

To create a notification workflow, please follow the following steps:

1. Click **Workflows** on the left sidebar of your Novu dashboard.

2. Click the **Add a Workflow** button on the top left.

3. Select **blank workflow** from the dropdown.

4. The name of a new workflow is currently "Untitled." Rename it to a suitable title.

5. Select any channel you want to use in your app. For the sake of this guide, we'll be using the 'Email' channel.
   <Frame>
     <img alt="Set email" />
   </Frame>

6. Click on the recently added channel, fill the email subject and click “Update”.
   <Frame>
     <img alt="Update email template" />
   </Frame>

7. Click on the “Test” tab and send a test email to verify your notification workflow.
   <Frame>
     <img alt="Send test email" />
   </Frame>

You should get an email within seconds. If you didn't, please check your 'spam' folder as sometimes test emails can end up there. Yaaay, you have successfully sent your first notification via the Novu dashboard!

Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display only one subscriber, as you were added automatically during sign-up. If default subscriber is not created, checkout [how to create new subscriber.](/subscribers/subscribers#create-a-subscriber)

<Frame>
  <img alt="Subscriber id" />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```python theme={null}
## Create a subscriber

from novu.api.subscriber import SubscriberApi
from novu.dto.subscriber import SubscriberDto

your_subscriber_id = "123" # Replace this with a unique user ID.

## Define a subscriber instance
subscriber = SubscriberDto(
   subscriber_id=your_subscriber_id,
   email="abc@gmail.com",
   first_name="John",
   last_name="Doe"
)

SubscriberApi().create(subscriber)

```

Run the code in your terminal like so:

```bash theme={null}
python main.py # replace main.py with your file name

```

You should see a new subscriber (that you created above) on your Novu dashboard.

## Update A Subscriber

To update the Subscriber details you can call the put method from SubcriberApi. Here is an example:

```python theme={null}
## Update subscriber detail

from novu.api.subscriber import SubscriberApi
from novu.dto.subscriber import SubscriberDto

subscriber = SubscriberDto(
   subscriber_id="123",
   email="new.abc@gmail.com",
   first_name="New",
   last_name="Name"
)

SubscriberApi().put(subscriber)

```

<Note>To send notifications to all your users, you'll need to make them subscribers in Novu, which you can do by programmatically adding them to Novu.</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```python theme={null}
from novu.api import EventApi

EventApi().trigger(
    name="test",  # The trigger ID of the workflow. It can be found on the workflow page.
    recipients="123",
    payload={},  # Your Novu payload goes here
)

```

Before running the code, make sure you understand the following:

* The value of `name` should be the notification workflow's trigger ID/slug.

<Frame>
  <img alt="Trigger id" />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the notification template content.
* The value of `recipients` is the id of the subscriber on Novu. Replace `123` with your subscriber ID.

Run the code to trigger a notification!

```bash theme={null}
python main.py # replace main.py with your file name

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```python theme={null}
from novu.api import TopicApi

## Create a topic
TopicApi().create(
    key="new-customers", name="New business customers"
)

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```python theme={null}
from novu.api import TopicApi

## Add a list of subscribers to a topic
TopicApi().subscribe(key="new-customers", subscribers="<LIST_OF_SUBSCRIBER_IDs>")

```

On the other hand, if you want to remove subscribers from a topic, do the following:

```python theme={null}
from novu.api import TopicApi

## Unsubscribe a list of subscribers from a topic
TopicApi().unsubscribe(key="new-customers", subscribers="<LIST_OF_SUBSCRIBER_IDs>")

```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```python theme={null}
from novu.api import EventApi
from novu.dto.topic import TriggerTopicDto

topics = TriggerTopicDto(
   topic_key="new-customers",
   type="Topic",
)

EventApi().trigger_topic(
    name="test",  # The trigger ID of the workflow. It can be found on the workflow page.
    topics=topics,
    payload={},  # Your Novu payload goes here
)

```

## Next Steps

Great job! If you've reached this point, you should now have successfully set up a channel provider, created a notification workflow, created a subscriber, updated a subscriber and triggered a notification in your application.

To learn more about notifications and explore Novu's features and capabilities, check out:

* [Novu Digest Engine](/workflows/digest) - Learn how to aggregate multiple trigger events into a single message and deliver it to the subscriber.
* [Novu Python SDK](https://github.com/novuhq/novu-python) - Delve deeper into the SDK and explore a lot of features.
* [Novu Python Cookbook](https://novu-python.readthedocs.io/en/latest/) - Learn how to use the SDK features.


# React
Source: https://v0.x-docs.novu.co/quickstarts/react

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with React.

Send notifications across different channels (SMS, Email, Chat, Push) and enable real-time In-App notifications with the help of a rich and customizable Notification Center.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-react) if you don’t have one yet.
* A working React development environment.

You can find the code for this project [here](https://github.com/novuhq/react-quickstart)

## Install the Novu React Notification Center Package in your React app

The Novu React package provides a React component library that you can use to add a fully functioning notification center to your React application.

To use it, first, install the React Notification Center package by running the following command in your terminal:

```bash theme={null}
npm install @novu/notification-center

```

Before you can use Novu in your React app, you'll need two things:

1. Create a workflow to use for sending notifications, and
2. Create a subscriber - recipient of notifications.

## Create a workflow

Before triggering a notification, we need to create a workflow. A workflow is like a blueprint that all the notifications are supposed to follow.

> The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

These are the steps to create a workflow:

1. Click **Workflow** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **"Untitled"**. Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.

   <Frame>
     <img />
   </Frame>
5. Click on the recently added "In-App" channel and configure it according to your preferences. Once you're done, click "Update" to save your configuration.

   <Frame>
     <img />
   </Frame>

   I'll briefly explain the function of each label in the image above:

* **1-Preview**: This shows you a glimpse of how each notification item will look in the Notification Center UI.
* **2-Avatar**: If turned on, each notification item will show the avatar of the subscriber.
* **3-Action**: With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds**: This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL**: This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter**: This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).
* **7-Editor**: You can add text that you want to be displayed in each notification item. Additionally, you can specify custom variables using `{{ }}`. This means you can inject variables from your code into a notification item's text via a payload.

In our case, we'll use the custom variables functionality, as shown below:

<Frame>
  <img />
</Frame>

Feel free to add only text for now and rename the workflow to quick start. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

<Frame>
  <img />
</Frame>

Now, we’ll learn how to create subscribers on Novu - Recipients of Notifications!

## Create a subscriber

If you click “Subscriber” on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-react), you’ll see the subscriber list. By default, there will only be one subscriber as you’re automatically added as a subscriber when you sign up for Novu:

<Frame>
  <img />
</Frame>

<Note>If you don't see the default subscriber, follow [how to create subscriber](/subscribers/subscribers#create-a-subscriber) documentation to learn on how to create one </Note>

Now, let’s create a subscriber on Novu. After creating a subscriber, we’ll trigger a notification to this subscriber. Subscribers are identified by a unique `subscriberId`.

With Novu, you can create a subscriber using any of its SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin). The NodeJS code to create a subscriber in Novu is:

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<NOVU_API_KEY>");

await novu.subscribers.identify("789", {
  firstName: "Sumit",
  lastName: "Saurabh",
});
```

The `identify` method used above either updates an existing subscriber using the payload data if a subscriber with the same `subscriberId` already exists, or creates a new one if it doesn't. Here, since no subscriber with `firstName` of `Sumit` and `lastName` of `Saurabh` exists, a new one was created and we can now send a notification to this subscriber by triggering a workflow.

<Info>
  You can read more about the `identify` method in our
  [docs](https://docs.novu.co/subscribers/subscribers#create-a-subscriber)
</Info>

You can get your API key from the Novu dashboard. Replace `<NOVU_API_KEY>` with it. Now, head over to the Novu dashboard and see the newly created subscriber above with a `subscriberId` of `789`.

You can also update information about an already existing subscriber using the `subscriber.update` method as shown below:

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<NOVU_API_KEY>");

await novu.subscribers.update("789", {
  firstName: "Saurabh", // new first name
  lastName: "Sumit", // new last name
});
```

## Using Novu in a React app

We have already installed the Novu notification center package above. To use it in an app, simply import it and add the component to your React app as follows:

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
} from "@novu/notification-center";

function App() {
  return (
    <>
      <NovuProvider
        subscriberId={process.env.REACT_APP_SUB_ID}
        applicationIdentifier={process.env.REACT_APP_APP_ID}
      >
        <PopoverNotificationCenter>
          {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
        </PopoverNotificationCenter>
      </NovuProvider>
    </>
  );
}

export default App;
```

You'll notice two things used above - `applicationIdentifier` and `subscriberID`.

An application identifier is a public key used to identify your application. You can get your own application identifier from the [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-react).

And subscribers are users to whom notifications will be sent. They are identified by a `subscriberID` which you can also find in the [Novu subscribers dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-react).

## Trigger a notification

We can trigger a notification by simply running the code below with the correct credentials;

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<API_KEY>");

novu.trigger("quickstart", {
  to: {
    subscriberId: "789",
  },
  payload: {
    description: "Test notification",
  },
});
```

This will take the workflow we created above with the identifier `quickstart` and send a notification to the subscriber with `subscriberId` of `789`.

> Make sure you're executing this code with the correct credentials.

## Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification centre, created a subscriber, a workflow, and triggered a notification in your React application.


# RedwoodJS
Source: https://v0.x-docs.novu.co/quickstarts/redwoodjs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with RedwoodJS.

Send notifications across different channels (SMS, Email, Chat, Push) and enable real-time In-App notifications with the help of a rich and customizable Notification Center in a RedwoodJS app.

Explore the code for [this quickstart on GitHub](https://github.com/novuhq/redwoodjs-quickstart/).

Explore the [live demo](https://novu-redwoodjs-blog.netlify.app/contact).

# Prerequisites

To follow the steps in this quickstart, you'll need:

* A Novu account. If you don't have one, [sign up for free](https://web.novu.co?utm_campaign=docs-gs-quick-redwoodjs).
* Node.js installed on your development machine.

# Create a RedwoodJS app

Clone the popular RedwoodJS blog tutorial app by running the following command in your terminal:

```bash theme={null}
git clone https://github.com/redwoodjs/redwood-tutorial
cd redwood-tutorial
yarn install
yarn rw prisma migrate dev
yarn rw prisma db seed
yarn rw dev

```

# Install Novu

To install Novu's In-App notification center, simply issue the following command:

```bash theme={null}
yarn workspace web add @novu/notification-center

```

Next, install Novu's Node SDK to fire notifications from the api/backend:

```bash theme={null}
yarn workspace api add @novu/node

```

## Register The Notification Center Component

Head over to `web/src/layouts/BlogLayout/BlogLayout.js` file of the recently cloned project and add the Novu In-App Notification center.

The file should look like this:

```javascript theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
} from "@novu/notification-center";

import { Link, routes } from "@redwoodjs/router";

import { useAuth } from "src/auth";

const BlogLayout = ({ children }) => {
  const { logOut, isAuthenticated, currentUser } = useAuth();
  const SUBSCRIBER_ID = process.env.REDWOOD_ENV_SUBSCRIBER_ID;
  const APPLICATION_IDENTIFIER = process.env.REDWOOD_ENV_APPLICATION_IDENTIFIER;

  return (
    <>
      <header className="relative flex justify-between items-center py-4 px-8 bg-blue-700 text-white">
        <h1 className="text-5xl font-semibold tracking-tight">
          <Link
            className="text-blue-400 hover:text-blue-100 transition duration-100"
            to={routes.home()}
          >
            Redwood Blog with <em>Novu</em>
          </Link>
        </h1>
        <nav>
          <ul className="relative flex items-center font-light">
            <li>
              <NovuProvider
                subscriberId={SUBSCRIBER_ID}
                applicationIdentifier={APPLICATION_IDENTIFIER}
              >
                <PopoverNotificationCenter
                  showUserPreferences={true}
                  position="top-start"
                >
                  {({ unseenCount }) => (
                    <NotificationBell unseenCount={unseenCount} />
                  )}
                </PopoverNotificationCenter>
              </NovuProvider>
            </li>
            <li>
              <Link
                className="py-2 px-4 hover:bg-blue-600 transition duration-100 rounded"
                to={routes.about()}
              >
                About
              </Link>
            </li>
            <li>
              <Link
                className="py-2 px-4 hover:bg-blue-600 transition duration-100 rounded"
                to={routes.contact()}
              >
                Contact
              </Link>
            </li>
            <li>
              {isAuthenticated ? (
                <div>
                  <button type="button" onClick={logOut} className="py-2 px-4">
                    Logout
                  </button>
                </div>
              ) : (
                <Link to={routes.login()} className="py-2 px-4">
                  Login
                </Link>
              )}
            </li>
          </ul>
          {isAuthenticated && (
            <div className="absolute bottom-1 right-0 mr-12 text-xs text-blue-300">
              {currentUser.email}
            </div>
          )}
        </nav>
      </header>
      <main className="max-w-4xl mx-auto p-12 bg-white shadow rounded-b">
        {children}
      </main>
    </>
  );
};

export default BlogLayout;
```

<Note>
  Add `REDWOOD_ENV_APPLICATION_IDENTIFIER` and `REDWOOD_ENV_SUBSCRIBER_ID` to
  the `.env` file.
</Note>

The `Subscriber ID` ideally should be the `id` of the **logged in user**. When a user logs into your app, they’ll be able to see all their notifications in the notification center. For this to work successfully, the user should have been created as a subscriber on Novu.

The `Application Identifier` is a public key used to identify your application.

Head over to your [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-redwoodjs), copy the application identifier and add it as the value of `REDWOOD_ENV_APPLICATION_IDENTIFIER`.

Head over to [the Subscribers page](https://web.novu.co/subscribers?utm_campaign=docs-quick-redwoodjs), grab a subscriber identifier and add it as the value of `REDWOOD_ENV_SUBSCRIBER_ID` in the `.env` file.

Now, check your app, you will see a notification bell button. Click on the button to reveal the notification center UI. Voila!

<Note>
  There are no notifications because none has been triggered yet. When
  notifications are sent to a subscriber, it will show up in the UI. Next, we'll
  learn how to trigger notifications.
</Note>

# Create A Workflow

The first step to trigger notifications is to create a workflow. A workflow is like a map that holds the entire flow of messages sent to the subscriber.

<Note>The recipients of a triggered notification are called subscribers.</Note>

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Add a workflow** button on the top left.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.
5. Click on the recently added In-App channel and configure it.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).

In the In-App channel `Editor`, add the following content and rename the step to `Onboarding In App` :

```javascript theme={null}
Hi {{ name }},
<br/>
<p>Thanks for indicating interest in attending RedwoodJS conference. Here is your message: </p>

<p>{{ message }}</p>

```

<Note>
  `{{ name }}` and `{{ message }}` are payload values that will be passed on from
  our code to the workflow template so it can appear in the notification sent to
  subscribers.
</Note>

Click on the `Update` button to save the configuration successfully!

6. In the workflow page, drag and drop the **Email** channel to the workflow canvas to be just below the `In-App` channel.
7. Click on the recently added Email channel and configure it:

Add `Sender name` and `Subject`. Ensure the `Default Layout` is selected for the Email Layout.

Switch to the `Custom Code` section and add the following:

```javascript theme={null}
Hi {{ name }},

<br />
<p>Thank you for attending RedwoodJS Conference. This means a lot to us!</p>
<br />
<p>Here is your message:</p>

{{ message }}

```

Finally, give the workflow a name. We'll need the workflow trigger identifier ***(which is the slug of the name)*** later.

Next, we’ll learn how to trigger notifications to subscribers.

# Trigger A Notification

Open up `api/src/services/contacts/contacts.js`, and add the following code into your app to trigger a notification:

```javascript theme={null}
import { Novu } from '@novu/node'

const novu = new Novu(process.env.NOVU_API_KEY)

export async function sendNotification(email, name, message) {
  await novu.trigger('<workflow-trigger-id>', {
    to: {
      subscriberId: process.env.REDWOOD_ENV_SUBSCRIBER_ID,
      email: email,
    },
    payload: {
      name: name,
      message: message,
    },
  })
}

...

...

/** In the createContact code, call the sendNotification and pass in the email, name and message */
export const createContact = ({ input }) => {
  validate(input.email, 'email', { email: true })

  sendNotification(input.email, input.name, input.message)

  return db.contact.create({
    data: input,
  })
}

...
...

```

Before running the code, make sure you understand the following:

* The value of `<workflow-trigger-id>` should be the workflow’s trigger ID/slug.
* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu.
* Ensure `NOVU_API_KEY` is in the `.env` file and with the appropriate value gotten from the dashboard.

# One more thing

Head over to the [integrations store on your Novu dashboard](https://web.novu.co/integrations?utm_campaign=docs-quick-redwoodjs).

Select the **Novu Email Test Provider**, and mark as the primary provider for Emails. This ensures that all emails are sent via the Novu Email provider.

# Test the app

Ensure your app is still running and head over the `/contact` page in the app. Fill the form and click `Save`.

The app will trigger two notifications:

* An In-App notification
* An Email notification

# Conclusion

Great job! If you've reached this point, you should now have successfully created workflow, configured a channel provider, triggered a workflow, and sent an email and In-App notification.


# Ruby quickstart
Source: https://v0.x-docs.novu.co/quickstarts/ruby

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Ruby.

Learn how to integrate Novu into your Ruby project on the fly and send notifications across different channels (SMS, Email, Chat, Push).

Let's get started! 💪

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-ruby) if you don’t have one yet.
* A working Ruby development environment with at least version 2.6.0.

You can also [view the completed code](https://github.com/novuhq/novu-ruby-quickstart) of this quick start in a GitHub repo.

## Install Novu Ruby SDK

The [Ruby SDK](http://github.com/novuhq/novu-ruby) provides a fluent and expressive interface for interacting with Novu's API and managing notifications.

You can install the client library via RubyGems:

```ruby theme={null}
gem install novu

```

Or add it to your Gemfile:

```ruby theme={null}
gem 'novu'

```

Then run `bundle install`.

## Initialize & Configure the Novu Ruby SDK

To use the library, Create a new file `index.rb` then initialize the client with your API token:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

```

Replace the `<NOVU_API_KEY>` argument with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-ruby).

<Note>
  Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

To test your API key, call the methods on the client to interact with the Novu API and display the result on your ruby console:

```ruby theme={null}
puts client.notifications

```

Run the file `index.rb`:

```bash theme={null}
ruby index.rb

```

You should see a result as below:

```json theme={null}
{
  "page": 0,
  "totalCount": 0,
  "pageSize": 10,
  "data": []
}

```

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-ruby) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favorite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create A Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.

<Frame>
  <img />
</Frame>

3. The name of the new workflow is currently Untitled, rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select Email as the channel you want to add, by dragging it from the right sidebar.

<Frame>
  <img />
</Frame>

5. Click on the Email in the workflow and edit it as per this image. Don’t forget to add the fields in the editor which is supposed to be updated with dynamic values that will be sent when calling the API.

<Frame>
  <img />
</Frame>

6. Also, add the variables in the Variables section in the test tab and try testing it by sending the email to your email address using the Send Test Email button at the bottom right.

<Frame>
  <img />
</Frame>

You should get an email within seconds! 👌

Great, you have successfully sent your first notification via the Novu dashboard! Now, let’s take a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## Create subscriber

create_payload = {
    'subscriberId' => '7789', # replace with system_internal_user_id
    'firstName' => 'John', # optional
    'lastName' => 'Doe', # optional
}
client.create_subscriber(create_payload)

```

Run the code in your terminal:

```bash theme={null}
ruby index.rb

```

You should see the subscriber on your Novu dashboard.

\![https://res.cloudinary.com/dxc6bnman/image/upload/f\_auto,q\_auto/v1685466979/guides/Screenshot\_2023-05-14\_at\_11.06.38\_ugvmc0.png](https://res.cloudinary.com/dxc6bnman/image/upload/f_auto,q_auto/v1685466979/guides/Screenshot_2023-05-14_at_11.06.38_ugvmc0.png)

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `updateSubscriber` method like so:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## Update subscriber detail

update_payload = {
    'email' => 'validemail@gmail.com',  # replace with valid email
    'firstName' => '<insert-firstname>', # optional
    'lastName' => 'Obasanjo', # optional
}
client.update_subscriber('7789', update_payload);
```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an object of metadata that you want to attach to the subscriber.

<Note>
  To make all of your app users subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## trigger a notification

trigger_payload = {
    'name' => 'Trigger1',
    'payload' => {
        'first-name' => 'Adam'
    },
    'to' => {
        'subscriberId' => '7789'
    }
}
client.trigger_event(trigger_payload)

```

Before running the code, make sure you understand the following:

* The value of `name` should be the workflow’s trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriber ID.

Run the code to trigger a notification!

```bash theme={null}
ruby index.rb

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safeguards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')
## Create a Topic

create_topic_payload = {
    'key'  => 'frontend-users',
    'name' => 'All frontend users'
}
client.create_topic(create_topic_payload)

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add and Remove Subscribers to a Topic

Copy and paste the following code into your app to add subscribers to a topic:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

topicKey = 'frontend-users'
subscribers = ['6460925ce1a93324257d2fc1', '7789'].to_s

## Add subscribers to a topic
client.add_subscribers(topicKey, subscribers)

```

Also, you can remove subscribers from a topic by using the code snippet below:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

topicKey = 'frontend-users'
subscribers = ['6460925ce1a93324257d2fc1', '7789'].to_s

## Remove subscribers from a topic
client.remove_subscribers(topicKey, subscribers)

```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## Send notifications to a topic (all frontend users)
client.trigger_event({
    'name' => 'Trigger1',
    'to' => {
        'type' => 'Topic',
        'topicKey' => 'frontend-users'
    }
})

```

<Note>
  The value of the `name` key in the payload should be the name of the notification created earlier.
</Note>

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider and triggered a notification in your application.


# VanillaJS
Source: https://v0.x-docs.novu.co/quickstarts/vanillajs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with VanillaJS.

Learn how to integrate Novu into your vanilla JS app on the fly. Send notifications across different channels (SMS, Email, Chat, Push) and enable real-time In-App notifications with the help of a rich and customizable Notification Center.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-vanilla) if you don’t have one yet.
* A working Vanilla JS development environment.

You can find the code for this project [here](https://github.com/novuhq/vanillajs-quickstart)

## Loading Notification center component from the CDN

The Notification Center Web Component is a custom element that can be used in any web application.

You can find out more about the web component [here](https://docs.novu.co/notification-center/web-component/).

In our case, we'll be using the bundled version of the Notification Center Web Component that is available on the CDN.

You can load the Notification center component using the CDN as follows:

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    ...
    <!-- CDN link for Novu notification center component -->
    <script src="​https://web-component.novu.co/index.js"></script>
  </head>
  <body>
    <!-- HTML body -->
    <!-- the notification center -->
    <notification-center-component
      style="display: inline-flex"
      application-identifier="<YOUR_APPLICATION_IDENTIFIER>"
      subscriber-id="<YOUR_SUBSCRIBER_ID>"
    ></notification-center-component>
  </body>
</html>

```

You'll notice the use of two things in the above code - `application-identifier` and `subscriber-id`.

An application identifier is a public key used to identify your application. You can get your own application identifier from the [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-vanilla).

And subscribers are users to which notifications will be sent. They are identified by a `subscriberID` which you can also find in the [Novu subscribers dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-vanilla). Let's learn more about subscribers.

## Subscribers in Novu

If you click “Subscriber” on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-vanilla), you’ll see the subscriber list. By default, there will only be one subscriber as you’re automatically added as a subscriber when you sign up for Novu:

<Frame>
  <img />
</Frame>

<Note>If you don't see the default subscriber, follow [how to create subscriber](/subscribers/subscribers#create-a-subscriber) documentation to learn on how to create one </Note>

Now, let’s create a subscriber on Novu. After creating a subscriber, we’ll trigger a notification to this subscriber. Subscribers are identified by a unique `subscriberId`.

With Novu, you can create a subscriber using any of its SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin). The code to create a subscriber in Novu is:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.identify('123', {
  firstName: 'Sumit',
  lastName: 'Saurabh',
  returnUser: true,
});
```

You can get your API key from the Novu dashboard. Replace `<NOVU_API_KEY>` with it. Now, if you’ll go to the Novu dashboard, you shall see the subscriber we created above with `subscriberId` of `123`.

You can also update information about an already existing subscriber using the `subscriber.update` method as shown below:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('123', {
  firstName: 'Saurabh', // new first name
  lastName: 'Sumit', // new last name
});
```

## Create a workflow

Before triggering a notification, we need to create a workflow. A workflow is like a blueprint that all the notifications are supposed to follow.

> The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

These are the steps to create a workflow:

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **"Create Workflow"** button on the top right.
3. The name of the new workflow is currently **"Untitled"**. Rename it to a more suitable title.
4. Select **"In-App"** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added In-App channel and configure it according to your preferences. Once you’re done, click Update to save your configuration.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.

In our case, we'll use the custom variables functionality, as shown below:

<Frame>
  <img />
</Frame>

Feel free to add only text for now and rename the workflow to quickstart. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

Having created a workflow and having our `subscriberID`, we're ready to send notifications using Novu!

## Using Novu in a vanilla JS app

We have already used the CDN to get the notification center component and we already have all the credentials that we need. To use it in an app, simply use the `notification-center-component` in your html file as shown below.

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    ...
    <!-- CDN link for Novu notification center component -->
    <script src="​https://web-component.novu.co/index.js"></script>
  </head>
  <body>
    <notification-center-component
      style="display: inline-flex"
      application-identifier="<YOUR_APPLICATION_IDENTIFIER>"
      subscriber-id="<YOUR_SUBSCRIBER_ID>"
    ></notification-center-component>

    <script>
      // here you can attach any callbacks, interact with the web component API
      // You can also move this to a separate js file and have all the callbacks and other logic there
      let nc =document.getElementsByTagName('notification-center-component')[0];
      nc.onLoad = () => console.log('hello world!');
    </script>
  </body>
</html>
```

You can add all the logic you want to add to the `script` element at the bottom or move it all into a separate JavaScript file (don't forger to link to the JavaScript file in this case).

Here's an example of such an HTML file:

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <script src="​https://web-component.novu.co/index.js"></script>

    <title>Vanilla JS app</title>
  </head>

  <body>
    <div>
      <h1>Notification generator</h1>
      <notification-center-component
        style="display: inline-flex"
        application-identifier="<YOUR_NOVU_APPLICATION_IDENTIFIER>"
        subscriber-id="123"
      ></notification-center-component>
    </div>
    <div class="">
      <form action="#" method="post" class="form">
        <input class="input" placeholder="Enter notification text" type="text" name="description" />
        <button class="btn">Send</button>
      </form>
    </div>
  </body>
  <script src="./app.js"></script>
</html>
```

And the corresponding script file is as follows:

```jsx theme={null}
const btn =document.querySelector('.btn');
const input =document.querySelector('.input');
const form =document.querySelector('.form');

const onClickHandler = async (e) => {
  e.preventDefault();
  const desc = input.value;
  console.log(desc);
  try {
    const resp = await fetch('<The API route from your backend>', {
      method: 'POST',
      body: JSON.stringify({
        description: desc,
      }),
      headers: {
        'Content-Type': 'application/json',
      },
    });
    input.value = '';
    console.log(resp);
  } catch (err) {
    console.log(err);
  }
};

form.addEventListener('submit', onClickHandler);

// here you can attach any callbacks, interact with the web component API
let nc =document.getElementsByTagName('notification-center-component')[0];
nc.onLoad = () => console.log('hello world!');
```

The front-end as well as the back-end code for the sample application can be found [here](https://github.com/novuhq/vanillajs-quickstart) for illustration.

## Code to trigger the notification

We can trigger a notification by simply executing the trigger code snippet we get from the Novu web dashboard.

To get the snippet:

1. Go to **Workflows** in the left sidebar on Novu web dashboard.
2. Select the workflow.
3. Click the **Get Snippet** button on the top right.

Here's the trigger snippet you'll receive:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<API_KEY>');

novu.trigger('quickstart', {
  to: {
    subscriberId: '<REPLACE_WITH_DATA>',
  },
  payload: {
    description: '<REPLACE_WITH_DATA>',
  },
});
```

> Make sure you're executing this code with the correct credentials.

## Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, configured a channel provider and triggered a notification in your React application.


# Vue
Source: https://v0.x-docs.novu.co/quickstarts/vue

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Vue.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications and integrate a rich, customizable and ready-to-use realtime UI In-App notification center in Vue apps.

# Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-vue) if you don’t have one yet.
* A working Vue development environment with a Vue 3 version.

You can also [view the completed code](https://github.com/novuhq/vue-quickstart) of this quick start in a GitHub repo.

# Create a new Vue app

If you already have a working Vue app, please feel free to skip this section.

Create a new Vue 3 app by running the following command in your terminal:

```bash theme={null}
npx create-vue notifications-app
```

Interactively run through the questions and answer them according to your preference. Then `cd` into the `notifications-app` folder and run the following:

```bash theme={null}
npm install && npm run format && npm run dev
```

# Install Novu Vue Notification Center Package

The Novu Vue package provides a Vue component wrapper over the web component that you can use to integrate the notification center into your Vue application.

Now install the Vue Notification Center package by running the following command in your terminal:

```bash theme={null}
npm install @novu/notification-center-vue
```

## Register The Notification Center Plugin

First, register the notification center plugin in your app as a global component.

In your `main.js` or `main.ts` file, add it like so:

```tsx theme={null}
import { createApp } from 'vue';

import NotificationCenterPlugin from '@novu/notification-center-vue';
import '@novu/notification-center-vue/dist/style.css';

// your app component
import App from './App.vue';

const app = createApp(App);

app.use(NotificationCenterPlugin);
app.mount('#app');
```

# Use The Notification Center Component

Create a new file, `NotificationCenter.vue` in the `src/components` directory. This file will house the Notification Center component.

Add the `NotificationCenterComponent` like so:

***Using the Composition API***

```tsx theme={null}
<script lang="ts" setup>
    const subscriberId = 'INSERT_SUBSCRIBER_ID_HERE'
    const applicationIdentifier = import.meta.env.NOVU_APP_IDENTIFIER
    const sessionLoaded = () => {
        console.log("Notification Center session loaded successfully!")
    }
</script>

<template>
    <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>
```

src/components/NotificationCenter.vue

***Using the Options API***

```tsx theme={null}
<script lang="ts">
export default {
  data() {
    return {
      applicationIdentifier: import.meta.env.VITE_NOVU_APP_IDENTIFIER,
      subscriberId: 'INSERT_SUBSCRIBER_ID_HERE',
    };
  },
  methods: {
    sessionLoaded() {
      console.log('Session loaded!')
    },
  },
};
</script>

<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>
```

src/components/NotificationCenter.vue

The `subscriberId` ideally should be the `id` of the **logged in user**. When a user logs into your app, they’ll be able to see all their notifications in the notification center. For this to work successfully, the user should have been created as a subscriber on Novu.

The `applicationIdentifier` is a public key used to identify your application. Obtain it from your [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-vue), and add it to your `.env` file.

If there’s none, create a `.env` file and add it like so:

```
VITE_NOVU_APP_IDENTIFIER = YOUR_NOVU_APP_IDENTIFIER;
```

Replace `YOUR_NOVU_APP_IDENTIFIER` with the real value from your dashboard.

# Display The In-App Notification Center UI

If you started by creating a new Vue app, then do the following:

Head over to `src/views/HomeView.vue` and import the `NotificationCenter.vue` component.

Replace the entire file with the code below:

```tsx theme={null}
<script setup lang="ts">
import NotificationCenter from '../components/NotificationCenter.vue'
</script>

<template>
  <main>
    <NotificationCenter />
  </main>
</template>
```

src/views/HomeView\.vue

Run your app again. You will see a button with the text **Notifications: 0**. Click on the button to reveal the notification center UI. Voila!

<Note>
  There are no notifications because none has been triggered yet. When notifications are sent to a subscriber, it will show up in the UI. Next, we'll learn how to trigger notifications.
</Note>

There’s a probability you might want the general notification bell icon. By default, the component displays the bell icon.

Simply delete the button element. Your component should look like this:

```jsx theme={null}
<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
  </NotificationCenterComponent>
</template>
```

You should now see a **bell button** that opens the notification center when clicked. This bell can be customized to your preference, and we will style and modify it in a later step.

* [Vue Notification Center Example Repo](https://github.com/novuhq/examples/tree/main/vue-notification-center-example)

# Create A Workflow

The first step to trigger notifications is to create a workflow. A workflow is like a map that holds the entire flow of messages sent to the subscriber.

<Note>
  The recipients of a triggered notification are called subscribers.
</Note>

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added In-App channel and configure it according to your preferences. Once you’re done, click Update to save your configuration.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).

Feel free to add only text for now and rename the workflow to `Onboarding In App`. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Next, we’ll learn how to create subscribers on Novu - *Recipients of Notifications*

# Create A Subscriber

Click **Subscribers** on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-vue) to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu.

Novu has a plethora of backend SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin) to choose from to create a subscriber programmatically. This is the recommended method.

Obtain your API key from your [Novu dashboard.](https://web.novu.co/settings?utm_campaign=docs-quick-vue) Replace `<NOVU_API_KEY>` with it.

Now check your Novu dashboard. You should see the recently created subscriber.

You can also update the subscriber info like so:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('132', {
  email: 'janedoe@domain.com', // new email
  phone: '+19874567832', // new phone
});
```

# Trigger A Notification

To trigger a notification, simply run the codesandbox below with the correct credentials.

```jsx theme={null}
// code to trigger a notification
```

`onboarding-in-app` is the workflow identifier we created earlier.

Ensure the `subscriberId` value in the backend code that triggers the notification matches the `subscriberId` in your **NotificationCenterComponent** code.

```tsx theme={null}
<template>
    <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>

<script lang="ts" setup>
    const subscriberId = '132'
    const applicationIdentifier = import.meta.env.NOVU_APP_IDENTIFIER
    const sessionLoaded = () => {
        console.log("Notification Center session loaded successfully!")
    }
</script>
```

Check your app again. You should see the recently triggered notification!

# Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, configured a channel provider and triggered a notification in your Vue application.


# Preferences
Source: https://v0.x-docs.novu.co/subscribers/preferences



Novu provides a way to store user preferences in the subscribers data model.
This allows subscribers to specify and manage their preferences, without your intervention. Customizing preferences has become the standard expected behavior for people and Novu can take the technical burden of managing preferences off of you.

**Novu allows several levels of preferences:**

* Workflow level channel preferences
* Subscriber level channel preferences
* Global level channel preferences

## Workflow level channel preferences

When creating a new workflow on the Web platform, you can specify default preferences for the subscribers in channel settings. They will be used unless the subscriber overrides them by his own custom preference.

This will allow you to create sensible defaults but still provide the user with the ability to override them. Template level preference can be managed in channel settings. All channels are `ON` unless specified otherwise.

`Workflow Settings > Channels`

<img />

## Subscriber level channel preferences

Our notification center component will show a user the available preferences, user will be able to modify on the channel level. Critical workflows will be excluded from the list. Click on cog (setting) icon on notification center component to open subscriber channel preferences page.

<img />

<Note>
  Only channels with a matched step will be returned from the API in
  notification center preference page. In case no channel content was found, the
  API will return an empty array.
</Note>

## Global level channel preferences

<Info>Since v0.20.0</Info>

Subscribers can set global channel preferences, which override individual settings. For instance, if there are 10 workflows, and a subscriber wants to disable SMS notifications for all of them, they can do so with a single global preference.

### Get subscriber global preference

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.getGlobalPreference("subscriberId" );
    ```
  </Tab>
</Tabs>

[Get subscriber's global preference API](/api-reference/subscribers/get-subscriber-global-preferences)

### Update subscriber global preference

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    // enable in-app channel and disable email channel
    await novu.subscribers.updateGlobalPreference("subscriberId", {
      enabled: true,
      preferences: [{
        type: "in_app"
        enabled: true
      }, {
        type: "email"
        enabled: false
      }]
    });
    ```
  </Tab>
</Tabs>

[Update subscriber's global preference API](/api-reference/subscribers/update-subscriber-global-preference)

<Note>Global subscriber preference can be updated and accessed using API and SDK only. Currently we have not added support of global subscriber preference in UI.</Note>

## Exclude workflows from preferences (critical workflow)

In some cases, you don't want the subscriber to be able to unsubscribe from mandatory notifications such as Account Verification, Password Reset, etc...

In those cases you can turn off the toggle `Users will be able to manage subscriptions` in channel settings. Workflow will become `critical`, once this toggle is turned `OFF`. By default, every workflow is `non-critical` and subscribers can manage channel preferences irrespective of workflow-level channel preferences. Critical workflow will not show on the subscriber preferences page.

## Get subscriber preferences

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from "@novu/node";

    const novu = new Novu("<NOVU_API_KEY>");

    // 111 is subscriberId
    await novu.subscribers.getPreference("111");
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    // 111 is subscriberId
    $novu->getSubscriberPreferences('111')->toArray();
    ```
  </Tab>
</Tabs>

## Get subscriber preference by level

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu, PreferenceLevelEnum } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');
    // Get global level preference
    await novu.subscribers.getPreferenceByLevel("subscriberId", PreferenceLevelEnum.GLOBAL)

    // Get template level preference
    await novu.subscribers.getPreferenceByLevel("subscriberId", PreferenceLevelEnum.TEMPLATE);
    ```
  </Tab>
</Tabs>

## Update subscriber preference for a workflow

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu, ChannelTypeEnum } from "@novu/node";

    const novu = new Novu("<NOVU_API_KEY>");

    // enable in_app channel
    await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
      enabled: true,
      channel: { type: ChannelTypeEnum.IN_APP, enabled: true },
    });

    // enable email channel
    await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
      enabled: true,
      channel: { type: ChannelTypeEnum.EMAIL, enabled: true },
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    // enable in_app channel
    $novu->updateSubscriberPreference('subscriberId', 'workflowIdentfier', [
        'enabled' => true
        'channel' => [
          'type' => 'in_app',
          'enabled' => true
        ]
    ]);

    // enable email channel
    $novu->updateSubscriberPreference('subscriberId', 'workflowIdentfier', [
        'enabled' => true
        'channel' => [
          'type' => 'email',
          'enabled' => true
        ]
    ]);
    ```
  </Tab>
</Tabs>

## Order of priority of preferences

1. if `Users will be able to manage subscriptions` toggle is turned off i.e workflow is critical, this will override workflow level and subscriber level preferences and notification will always be sent.
2. if workflow is non critical and subscriber has `false` value set for `enabled` field in preference then all other channels will become inactive even if they have `true` state.
3. if workflow is non critical and subscriber has `true` value set for `enabled` field in preference then notification will be filtered based on subscriber channel preference.
4. Workflow level channel preferences will be applied to all subscribers by default unless subscriber overrides them.

`Example`

1. For `First Workflow`, `critical` is false, `enabled` is true, in\_app, email, push channels are true and sms, chat channels are false. As per above order of priority of preferences, notification will be filtered as per the subscriber preferences. The subscriber will receive in-app, email and push notifications, but not receive sms and chat notifications.

2. For `Second Workflow`, `critical` is false, `enabled` is false, all channels are true. As per above order of priority of preferences, subscriber will not receive any type of notification because all channels become disabled due to false value of `enabled` field.

3. For `Third Workflow`. `critical` is true, `enabled` is false, email, chat channels are false and the other three channels are true. As per above order of priority of preferences, subscriber will receive all type of notifications as this workflow is `critical`.

<Tabs>
  <Tab title="First Workflow">
    ```json theme={null}
    {
      "template": {
        "_id": "firstWorkflowIdentifier",
        "name": "First Workflow",
        "critical": false
      },
      "preference": {
        "enabled": true,
        "channels": {
          "in_app": true,
          "email": true,
          "sms": false,
          "push": true,
          "chat": false
        }
      }
    }
    ```
  </Tab>

  <Tab title="Second Workflow">
    ```json theme={null}
    {
      "template": {
        "_id": "secondWorkflowIdentifier",
        "name": "Second Workflow",
        "critical": false
      },
      "preference": {
        "enabled": false,
        "channels": {
          "in_app": true,
          "email": true,
          "sms": true,
          "push": true,
          "chat": true
        }
      }
    }
    ```
  </Tab>

  <Tab title="Third Workflow">
    ```json theme={null}
    {
      "template": {
        "_id": "thirdWorkflowIdentifier",
        "name": "Third Workflow",
        "critical": true
      },
      "preference": {
        "enabled": false,
        "channels": {
          "in_app": true,
          "email": false,
          "sms": true,
          "push": true,
          "chat": false
        }
      }
    }
    ```
  </Tab>
</Tabs>

## API

<CardGroup>
  <Card title="Get subscriber preferences API" icon="plug" href="/api-reference/subscribers/get-subscriber-preferences" />

  <Card title="Update subscriber preference for a workflow API" icon="plug" href="/api-reference/subscribers/update-subscriber-preference" />

  <Card title="Update workflow API" icon="plug" href="/api-reference/workflows/update-workflow" />
</CardGroup>

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="How to change enabled field from UI?">
    This field can only be changed using API.
  </Accordion>

  <Accordion title="What preferences are applied to a subscriber when we create a new workflow?">
    In the case of a new workflow, the subscriber will inherit all preferences
    from the workflow\.However, after subsequent preference updates, the
    subscriber's preferences will not inherit workflow-level preferences.
  </Accordion>

  <Accordion title="How to disable a workflow for a single subscriber?">
    You can turn off all workflow's channels for a subscriber using [subscriber preference](/subscribers/preferences#subscriber-level-channel-preferences). If all channels are off, then the subscriber will not receive any message from any channel step and hence workflow is disabled for that subscriber
  </Accordion>
</AccordionGroup>


# Subscribers
Source: https://v0.x-docs.novu.co/subscribers/subscribers



In Novu, we call the entities designed to receive notifications as `Subscribers`. Each subscriber is unique and identified by a unique subscriberId.

<Note>
  `subscriberId` is a unique identifier used by Novu to keep track of a specific subscriber.
  We recommend using the internal unique id your application uses for a specific user.
</Note>

Each subscriber has the following data points:

* **User Data** - Data stored in the subscriber object that you can easily access in your notification templates. This contains basic info such as first name, last name, avatar, locale, email, and phone. This data is fixed and structured.
* **Custom Data** - Apart from the above fixed structured user data, any unstructured custom data such as user's address, nationality, height, etc can also be stored in the `data` field using key-value pairs.
* **Channel Specific Credentials** - `deviceTokens` required to send push notifications and `webhookUrl` for chat channel providers can also be stored.

## Subscriber attributes

| Field        | Type   | Required | Example                                                                        |
| :----------- | :----- | :------- | :----------------------------------------------------------------------------- |
| subscriberId | string | true     | b0bea066-f5fe-11ed-b67e-0242ac120002                                           |
| firstName    | string | false    | John                                                                           |
| lastName     | string | false    | Doe                                                                            |
| email        | string | false    | [john.doe@domain.org](mailto:john.doe@domain.org).                             |
| phone        | string | false    | +13603963366                                                                   |
| locale       | string | false    | en                                                                             |
| avatar       | string | false    | [https://example.com/images/avatar.jpg](https://example.com/images/avatar.jpg) |
| data         | object | false    | `{"key": "value"}`                                                             |

## Subscriber response schema

**Novu subscriber object**

```json theme={null}
{
  "_id": "NOVU_GENERATED_SUBSCRIBER_ID",
  "_organizationId": "NOVU_GENERATED_ORG_ID",
  "_environmentId": "NOVU_GENERATED_ENV_ID",
  "firstName": "John",
  "lastName": "Doe",
  "subscriberId": "subscriberId",
  "email": "[john.doe@org.com](mailto:john.doe@org.com)",
  "phone": "+98712345670"
  "data": {
    "custome_key_1" : "custom_value_1",
    "custome_key_2" : "custom_value_2"
  }
  "channels": [
  {
    "credentials": {
      "deviceTokens": [
        "token1",
        "token2"
      ]
    },
    "_integrationId": "NOVU_GENERATED_INTEGRATION_ID",
    "providerId": "fcm"
  },
  {
    "credentials": {
      "webhookUrl": "URL"
    },
    "_integrationId": "NOVU_GENERATED_INTEGRATION_ID",
    "providerId": "discord"
  }
  ],
  "deleted": false,
  "createdAt": "2022-10-13T17:40:53.231Z",
  "updatedAt": "2022-10-13T17:41:53.238Z",
  "__v": 0,
  "isOnline": false,
  "lastOnlineAt": "2022-10-13T17:41:53.238Z",
  "avatar": "AVATAR_URL",
  "id": "NOVU_GENERATED_SUBSCRIBER_ID"
}
```

## Create a subscriber

You can create a subscriber in Novu using the `identify` method provided in Novu's SDK.

<Tip>The `identify` method serves the purpose of handling existing "subscriberId" providers within the database.
When a provider with the same subscriberId already exists, this method performs an update operation using the data present in the payload.
In cases where there is no pre-existing entry, the method generates a new one, thus exhibiting an <Tooltip>upsert</Tooltip>
behavior.</Tip>

<Note>
  It is possible for two subscribers to have the same email address in our system. This is because the `subscriberId` is the unique identifier that distinguishes one subscriber from another.
</Note>

```jsx theme={null}
import { Novu } from "@novu/node";

// Insert your Novu API Key here
const novu = new Novu("<NOVU_API_KEY>");

// Create a subscriber on Novu
await novu.subscribers.identify("132", {
  email: "john.doe@domain.com",
  firstName: "John",
  lastName: "Doe",
  phone: "+13603963366",
});
```

<Warning> The `phone` parameter must be parsed as a string.</Warning>

You should now be able to see your new subscriber on the Novu dashboard.

You can also add additional fields such as `phone`, `avatar`, and `data`.

<Note> Remember, all user IDs added to Novu need to be unique. </Note>

If you face issues with the subscriber creation only taking the user ID and omitting other fields such as firstName, lastName, etc., you could consider updating the subscriber after creation.

Please also be aware that although it's currently possible to create a subscriber with an empty `subscriberId`, this subscriber cannot be deleted later.

We support creating new subscriber using two ways, `Ahead of Trigger` means adding subscribers before triggering notification or `Inline of Trigger` means sending complete subscriber data in `to` field while triggering.

### 1. Ahead of Trigger

Create the subscriber and then trigger the notification to this subscriber. Here `subscriberId` is the required field and other fields are optional.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.identify('111', {
      email: 'john.doe@domain.com',
      firstName: 'John',
      lastName: 'Doe',
      phone: '+13603963366',
      avatar: 'https://example.com/images/avatar.jpg',
      locale: 'en-US',
      data: { customKey1: 'customVal1', customKey2: 'customVal2' },
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->createSubscriber([
        'subscriberId' => '111',
        'email' => 'john.doe@domain.com',
        'firstName' => 'John',
        'lastName' => 'Doe',
        'phone' => '+13603963366',
        'avatar' => 'https://example.com/images/avatar.jpg',
        'locale' => 'en',
        'data' => [
          'customKey1' => 'customVal1',
          'customKey2' => 'customVal2'
        ]
    ]);
    ```
  </Tab>
</Tabs>

Novu will create a subscriber if one does not exist and will update the existing subscriber based on the `identify` payload. You can call this function during registration or signup to make sure the subscriber data is up-to-date, if you wish to save additional attributes with a subscriber, you can pass additional custom data in the **data** field as key-value pairs.

### 2. Inline of Trigger

A non-existing subscriber can be added by sending subscriber data in `to` field of the trigger method. If any subscriber with provided `subscriberId` does not exists, a new subscriber will be created. In this case, subscriber will be created first and then the trigger will be executed synchronously.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '111',
        email: 'john.doe@domain.com',
        firstName: 'John',
        lastName: 'Doe',
        phone: '+13603963366',
      },
      payload: {
        customVariable: 'variableValue',
        organization: {
          logo: 'https://organization.com/logo.png',
        },
      },
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->triggerEvent([
      'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
      'to' => [
          'subscriberId' => '111',
          'email' => 'john.doe@domain.com',
          'firstName' => 'John',
          'lastName'  => 'Doe',
          'phone' => '+13603963366'
      ]
      'payload' => [
          'customVariable' => 'variableValue',
          'organization' => [
            'logo' => 'https://organization.com/logo.png',
          ]
        ],
    ]);
    ```
  </Tab>
</Tabs>

## Bulk Subscriber Creation

You can create subscribers in bulk *(up to 500 at once)* via the SDKs or [API](/api-reference/subscribers/bulk-create-subscribers).

<Note> The bulk subscriber creation feature is only available in v0.19.0 and above.</Note>

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    await novu.subscribers.bulkCreate([
      {
        subscriberId: 'test-subscriber-1',
        email: 'test-user@sd.com',
        firstName: 'subscriber-1',
        lastName: 'test-1',
      },
      {
        subscriberId: 'test-subscriber-2',
        email: 'test-user-2@sd.com',
        firstName: 'subscriber-2',
        lastName: 'test-2',
      },
      {
        subscriberId: 'test-subscriber-3',
      },
    ]);
    ```
  </Tab>
</Tabs>

## Import subscribers

Here, `mock_data.csv` file is a CSV file having mock data. The below script will read this CSV file and create a new subscriber in Novu. Change example variables values like `API_KEY` value with your valid values. Download `mock_data.csv` file from [here](https://drive.google.com/file/d/159Upw30ZcPa_QnzlKF-C6_dHKDJeU-TW/view).

<Note> `mock_data.csv` file should be in the same directory of script </Note>

Steps:

1. Export your user details in CSV format.
2. Clean this exported CSV file. Keep only relevant fields.
3. Move this CSV file to the script directory.
4. Change the file name in the script with your file name.
5. Run the script. (Make script.sh executable before using)

<Tabs>
  <Tab title="Shell">
    ```shell theme={null}
    #!/bin/bash

    # Change these variables with your own values
    CSV_FILE="mock_data.csv"
    API_ENDPOINT="https://api.novu.co/v1/subscribers"
    API_KEY="ApiKey <API_KEY>"

    OLDIFS=$IFS
    IFS=','
    [ ! -f $CSV_FILE ] && { echo "$CSV_FILE file not found"; exit 99; }

    SECONDS=0

    # Read the CSV file line by line
    while read subscriberId firstName lastName email phone locale avatar
    do
        # Check if subscriberId is empty or not present
        if [[ -z "$subscriberId" ]]; then
            echo "Skipping row with missing subscriberId"
            continue
        fi

        # Construct the JSON body for the POST request
        json_body="{\"subscriberId\": \"$subscriberId\""

        # Add optional fields to the JSON body if present
        if [[ -n "$firstName" ]]; then
            json_body="$json_body, \"firstName\": \"$firstName\""
        fi

        if [[ -n "$lastName" ]]; then
            json_body="$json_body, \"lastName\": \"$lastName\""
        fi

        if [[ -n "$email" ]]; then
            # Validate email using regex
            if [[ ! "$email" =~ ^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$ ]]; then
                echo "Invalid email format for subscriberId: $subscriberId"
                continue
            fi
            json_body="$json_body, \"email\": \"$email\""
        fi

        if [[ -n "$phone" ]]; then
            json_body="$json_body, \"phone\": \"$phone\""
        fi

        if [[ -n "$locale" ]]; then
            # Validate locale using regex
            if [[ ! "$locale" =~ ^[a-zA-Z]{2}(-[a-zA-Z]{2})?$ ]]; then
                echo "Invalid locale format for subscriberId: $subscriberId"
                continue
            fi
            json_body="$json_body, \"locale\": \"$locale\""
        fi

        if [[ -n "$avatar" ]]; then
            json_body="$json_body, \"avatar\": \"$avatar\""
        fi

        if [[ -n "$address" || -n "$job" ]]; then
            json_body="$json_body, \"data\": {"

            if [[ -n "$address" ]]; then
                json_body="$json_body \"address\": \"$address\""
            else
                json_body="$json_body \"address\": \"\""
            fi

            if [[ -n "$job" ]]; then
                json_body="$json_body, \"job\": \"$job\""
            else
                json_body="$json_body, \"job\": \"\""
            fi

            json_body="$json_body }"
        fi

        json_body="$json_body}"

        echo $json_body

        #Send the cURL POST request with the JSON body and handle exceptions
        response=$(curl -s -X POST -H "Content-Type: application/json" -H "Authorization: $API_KEY" -d "$json_body" -w "%{http_code}" "$API_ENDPOINT")

        http_code=${response:${#response}-3}

        if [[ $http_code -eq 201 ]]; then
            echo "cURL request successful for subscriberId: $subscriberId - HTTP Status Code: $http_code"
        else
            echo "cURL request failed for subscriberId: $subscriberId - HTTP Status Code: $http_code - response : $response"
        fi

    done < "$CSV_FILE"

    ELAPSED="Time Elapsed: $(($SECONDS / 3600))hrs $((($SECONDS / 60) % 60))min $(($SECONDS % 60))sec"

    echo $ELAPSED
    ```
  </Tab>

  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';
    require('dotenv').config();

    const csv = require('csv-parser');
    const fs = require('fs');

    const novu = new Novu('<NOVU_API_KEY>');

    fs.createReadStream('mock_data.csv')
      .pipe(csv())
      .on('data', async (data) => {
        let subscriber = await novu.subscribers.identify(data.subscriberId, {
          email: data.email,
          firstName: data.firstName,
          lastName: data.lastName,
          phone: data.phone,
          avatar: data.avatar,
          locale: data.locale,
          data: { address: data.address, job: data.job },
        });

        console.log(subscriber.data);
      })
      .on('end', () => {
        console.log('done');
      });
    ```
  </Tab>
</Tabs>

## Delete a subscriber

To stop a subscriber from receiving notifications, you can delete the subscriber. This will hard delete the subscriber and means you will not be able to access this subscriber later. You will have to create this subscriber again.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.delete('111');
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->deleteSubscriber('111');
    ```
  </Tab>
</Tabs>

## Update a subscriber

In some cases, you want to access a subscriber to update a specific user data field or custom data field. For example, when the users change their email address or personal details.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.update('111', {
      // new email
      email: 'john@domain.com',
      // new phone
      phone: '+19874567832',
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->updateSubscriber('111', [
        // new email
        'email' => 'john@domain.com',
        // new phone
        'phone' => '+19874567832',
    ])->toArray();
    ```
  </Tab>
</Tabs>

## Find a subscriber

Any subscriber can be retrieved using a unique subscriber identifier `subscriberId`. Check the returned subscriber schema [here](#subscriber-response-schema).

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.get('111');
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->getSubscriber('111')->toArray();
    ```
  </Tab>
</Tabs>


# Topics
Source: https://v0.x-docs.novu.co/subscribers/topics



Novu offers a simple API providing an easy interface for triggering notifications to multiple subscribers at once. It is called Topics and allows the users to manage their bulk notifications without having to do complex loop implementations. A topic is identified by a custom key that is provided by the user. This custom key will be the identifier for the topic.

<Warning>
  The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.
</Warning>

Users can also assign a name to a topic. This name doesn't need to be unique and it can be changed using the API. So far, it is for descriptive goals.

A topic would get assigned different subscribers that will receive a notification every time a notification is sent to the topic.

## Create A Topic

In order to be able to send a notification to a topic, first the user needs to create one. It can be done like this:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const result = await novu.topics.create({
  key: 'unique-topic-identifier',
  name: 'descriptive-topic-name',
});
```

If successful this will return the internal Id generated by Novu and the topic key given by the user.

That topic key can be used to retrieve the whole Topic entity:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const key = 'unique-topic-identifier';

const result = await novu.topics.get(key);
```

## Rename a Topic

Descriptive name given during creation of topic can be changed later. This can be done like this:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const topicKey = 'posts:comment:12345';
const topicName = 'Post Comments';

const result = await novu.topics.rename(topicKey, topicName);
```

This will return the whole Topic information, including the subscribers if having any.

<Note>Topic Key can not be changed</Note>

## Add subscribers to a Topic

Adding subscribers to the topic is the main usecase of topic. A topic is like a group of subscribers. A notification can be sent to all subscribers of a topic at once

<Warning>
  Before adding subscribers to a topic, it's crucial to ensure that they are correctly identified in the Novu system. This identification is done using the [identify method](/subscribers/subscribers#create-a-subscriber) or API. When a subscriber is added to a topic, Novu uses the identification information to pick up the email or phone number associated with the subscriber.
</Warning>

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const topicKey = 'posts:comment:12345';

const response = await novu.topics.addSubscribers(topicKey, {
  subscribers: ['subscriber-id-1', 'subscriber-id-2', ...],
});
```

This call will return a response in the shape of:

```typescript theme={null}
{
    succeeded: ['subscriber-id-1', 'subscriber-id-2', ...],
    failed: {
      notFound: ['subscriber-id-1', 'subscriber-id-2', ...],
    },
}
```

The field `succeeded` will return the array of subscriber ids that have been correctly assigned to the topic. The field `failed` will show up only if there has been any subscriber that couldn't been assigned to the topic. This probably will happen if there is any typo in the given subscriberId or if the given subscriberId doesn't belong to the environment and the organization where the topic has been created.

### Create topic on the fly

To facilitate flows we allow to create a topic on the fly when adding subscribers.

If the topic key used does not exist for the selected environment and organization, Novu will create a new topic with name `Autogenerated-<TOPIC_KEY>` and the subscribers will be assigned to this newly created topic.

After that, that topic created on the fly can be managed in the same ways as the ones created in the normal way.

## Verify if subscriberId belongs to a topic

There would be times when it would be needed to verify if a certain subscriber belongs to a topic in order to decide what to do with that subscriber. The API call to achieve that is the following:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const externalSubscriberId = 'external-subscriber-id-1';
const topicKey = 'posts:comment:12345';

const response = await novu.topics.getSubscriber(topicKey, externalSubscriberId);
```

<Note>
  The subscriberId to use in this API call is the one used as subscriber identifier.
  The choice was made to make easier for the user to use this without making extra calls to Novu.
</Note>

## Remove a subscriber from a Topic

A single or group of subscribers can be removed from an existing topic.

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const topicKey = 'posts:comment:12345';

const response = await novu.topics.removeSubscribers(topicKey, {
  subscribers: ['subscriber-id-1', 'subscriber-id-2', ...],
});
```

Where `subscribers` will be an array of the subscriberIds we want to remove from the topic. If successful an empty response will be returned.

## Delete a topic

An existing topic can be deleted using topic-key as topic-key is the unique identifier for a topic.

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const key = 'unique-topic-identifier';

const result = await novu.topics.delete(key);
```

<Warning>
  A topic can only be deleted if it doesn't have any subscriber added. When trying to delete a topic with subscribers a conflict error will be returned. This is done to prevent accidental topic deletions.
</Warning>

## Trigger workflow to a topic

A workflow can be triggered to a single subscriber and an array of subscribers. While doing so, one need to send subscriberIds in `to` field. In case of trigger, we have already stored subscriberIds in a topic, so a topic key can be used to trigger a workflow. Workflow will be triggered to all subscribers in the topic.

```typescript theme={null}
const topicKey = 'posts:comment:12345';

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: [{ type: 'Topic', topicKey: topicKey }],
  payload: {},
});
```

## Trigger workflow to multiple topics

Workflow can be triggered to multiple subscribers by using an array of topics.

```typescript theme={null}
const topicKey = '<TOPIC-KEY-DEFINED-BY-THE-USER>';

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: [
    { type: 'Topic', topicKey: topicKey },
    { type: 'Topic', topicKey: 'Another Topic Key' },
  ],
  payload: {},
});
```

## Exclude actor from topic trigger event

To exclude the actor responsible for the action of a triggered topic event, you must add the subscriberId of that actor when triggering that event.

```typescript theme={null}
const topicKey = 'posts:comment:12345';

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: [{ type: 'Topic', topicKey: topicKey }],
  payload: {},
  actor: { subscriberId: '<SUBSCRIBER_ID_OF_ACTOR>' },
});
```

## Usecase Example

User X makes a comment, other users (A, B) who've already commented before should get a notification. So, when triggering the notification on that topic, you would usually want to exclude User X from receiving a notification about their own comment. To do that - you would need to add User X's subscriberId to the trigger event.

## API

<CardGroup>
  <Card title="Fetch list of topics" icon="plug" href="/api-reference/topics/filter-topics" />

  <Card title="Create a new topic" icon="plug" href="/api-reference/topics/topic-creation" />

  <Card title="Add subscribers to a topic" icon="plug" href="/api-reference/topics/subscribers-addition" />

  <Card title="Check if subscriber belongs to a topic" icon="plug" href="/api-reference/topics/check-topic-subscriber" />

  <Card title="Remove subscribers from a topic" icon="plug" href="/api-reference/topics/subscribers-removal" />

  <Card title="Fetch a topic by topic-key" icon="plug" href="/api-reference/topics/get-topic" />

  <Card title="Delete a topic" icon="plug" href="/api-reference/topics/delete-topic" />

  <Card title="Rename a topic" icon="plug" href=" /api-reference/topics/rename-a-topic" />
</CardGroup>

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="Does it mean that all subscribers of one topic have same preference">
    No, adding subscribers into topic does not change subscriber's individual [subscriber preference](/subscribers/preferences). Topic is mainly used to group subscribers and fan out workflow triggered notifications to all subscribers at once.
  </Accordion>
</AccordionGroup>


# Tenants
Source: https://v0.x-docs.novu.co/tenants/introduction

Learn all about Tenants

Multi-tenancy is a common use case for a lot of companies that have multiple organizations that use their applications. In some cases, there is a need to separate the behavior of the notification system depending on the individual tenants.

Currently, Novu supports the following customizations:

* Workflow level customizations
* Integration customizations

## Tenant Management

Tenants can be created and modified via the [API](http://docs.novu.co/api-reference/tenants/get-tenants) or [Web](https://web.novu.co/tenants?utm_campaign=docs-tenants). Each tenant can have multiple fields on it:

* Identifier - The identifier is a unique value, and can be used later when pointing to this tenant during trigger calls.
* Name - A human-readable name of the tenant.
* Data - A custom data object that can store information about the tenant. This data can be later accessed inside workflows.

To create a tenant on the Novu web platform, follow these steps:

* Click on `Tenants` on the left sidebar.
* In the Tenants section, click on the `Add a tenant` button.
* Set a `Name` and `Tenant identifier`. The tenant identifier is automatically set once you add a name. However, you can modify it to your needs.
* Set a JSON-format `Custom properties` (optional).

## Workflow Level Customizations

When triggering a workflow, it is possible to pass the tenant information (id or object, in case of an object, novu will upsert the tenant if it’s not existing) like so:

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
      import { Novu } from '@novu/node';

      const novu = new Novu("<NOVU_API_KEY>");

      await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
        {
          to: {
            subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          },
          payload: {
            name: "Hello World",
          },
          actor: "actorId"
          tenant: "tenantIdentifier"
        }
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
      use Novu\SDK\Novu;

      $novu = new Novu('<NOVU_API_KEY_HERE>');

      $novu->triggerEvent([
        'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
        'payload' => [
          'name' => 'Hello'
        ],
        'to' => [
            'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
        ],
        'actor': "actorId"
        'tenant': "tenantIdentifier"
      ]);
    ```
  </Tab>
</Tabs>

The tenant information can now be used inside the workflow template in the following way:

```
{{ tenant.data.customProp }}
```

## Workflow Settings Override

Workflow settings can now be updated on the workflow per tenant. This enables each tenant to have unique preferences that doesn't affect others within the same workflow.

The `active` and `channel` preferences fields of a workflow can be updated to be tenant-specific the [workflow-overrides API endpoint](/api-reference/workflow-overrides/create-workflow-overrides).

<Warning>This feature is only available from v0.22.0.</Warning>

## Integration Level Customizations

When creating an integration, you can create a condition where you can specify a delivery provider for a channel when a particular tenant id is matched.

The delivery provider specified will only be used if the trigger is executed with the tenant id.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Tenant-specific Notification Content

When creating a step, variants could be created for each step including digest and delay. For each variant, conditions set can be applied on when this variant could be used.

Using so different workflow configurations (for example digest duration) could be configured on the individual workflow for a given tenant.

For example, if you want a specific notification content to be sent to a tenant named "JohnDoe", and another to be sent to others. You can do the following:

* Create an email step in your workflow
* In the email step workflow, click on the "Add variant" icon at the top right to add a new variant.

<Frame>
  <img />
</Frame>

* It opens up the condition page. Set the tenant identifier to equal "JohnDoe".

<Frame>
  <img />
</Frame>

* Apply Conditions as shown above.
* Check the email step in the workflow, you'll see the **root variant** and **v1 variant**.

<Frame>
  <img />
</Frame>

Once a trigger runs, the Novu engine checks to see if there's a `tenant` identifier specified in the trigger code.

An example of the trigger code:

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
      import { Novu } from '@novu/node';

      const novu = new Novu("<NOVU_API_KEY>");

      await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
        {
          to: {
            subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          },
          tenant: "JohnDoe"
        }
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
      use Novu\SDK\Novu;

      $novu = new Novu('<NOVU_API_KEY_HERE>');

      $novu->triggerEvent([
        'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
        'to' => [
            'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
        ],
        'tenant': "JohnDoe"
      ]);
    ```
  </Tab>
</Tabs>

* If it exists, a condition check is done to see if there's a variant that matches the tenant identifier.
* If there's a match, the specific variant template will be fired.
* If there's no match, the root variant template will be fired.

It is also possible to use handlebars to have minor tenant adjustments in a single step:

```
<img src="{{tenant.data.logo}}" />
```

<Warning> For self-hosted users, this is only available from version 0.22.0. </Warning>


# Delay Action
Source: https://v0.x-docs.novu.co/workflows/delay-action

More on how Delay Action Node works

The delay action awaits a specified amount of time before moving on to trigger the following steps of the workflow.

### Delay Action Node

After adding a delay node in the workflow editor, the immediate next step will only be triggered after the specified period of time has elapsed.

# Configurations

## Regular Delay

Regular Delay will determine how long it will take before triggering the next step.

## Time Interval

You can specify the amount and time unit that best suits your needs.

Should you wish to, you could override the default delay time interval you set in the creation of the delay node.

```tsx theme={null}
novu.trigger('template-name', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>'
  },
  payload: {
    name: 'Hello',
  },
  overrides: {
    delay: {
      unit: 'days',
      amount: 2,
    },
  },
});
```

## Scheduled Delay

Scheduled Delay allows delaying up to a future date before continuation of steps execution. All steps after delay node will be triggered only after said date.

### Payload Path[](https://docs.novu.co/platform/delay#payload-path)

Payload path will determine the path in payload for the scheduled date.

That path must be included in your payload on trigger execution and must be a date in strict ISO format.

For example:

<img />

```tsx theme={null}
novu.trigger('workflow-name', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>'
  },
  payload: {
    sendAt: '2022-09-21T10:48:44.388Z',
  },
});
```

<Note>
  Date must be in ISO date format of YYYY-MM-DDThh:mm:ss.SSSZ
</Note>


# Digest Engine
Source: https://v0.x-docs.novu.co/workflows/digest

Deep dive into Digest functionality

The digest engine collects multiple trigger events, aggregates them into a single message and delivers it to the subscriber.

This becomes useful when a user needs to be notified on a large amount of triggers and you want to avoid sending too many notifications. Novu will automatically batch the incoming trigger events based on the `subscriberId` and an **optional** `digestKey` that can be added to control the digestion of the events.

### Digest Node

After adding a digest node in the workflow editor, each node that will be below the digest node will be only triggered once in the specified digest interval. You can decide to send messages before adding a digest node and they will be triggered in real-time.

<Frame>
  <img />
</Frame>

In the image above, there are two nodes (`Email` and `SMS`) after the digest node and one node (`In-App`) before the digest node in the workflow.

For this workflow, if we trigger 10 events within the digest interval, the `In-App` step will be executed 10 times, and `Email` and `SMS` will be executed only 1 time with digested events data.

## Digest Configuration

### 1. Digest Key

If specified, the digest engine will group the events based on the `digestKey` and `subscriberId`, otherwise the digest engine will group the events based only on the subscriberId.

The digest key might come useful when you want a particular subscriber to get events grouped on a custom field. For example when an actor likes the user's post, you might want to digest based on the `post_id` key.

<Frame>
  <img />
</Frame>

### 2. Time Interval

The time interval determines how long the digest engine will wait before sending the message once created. You can specify the amount and the unit that best suits your needs.

Here, in the image below, `5` is the interval amount, and `mins` is the interval unit. Interval units can be `sec(s)`, `min(s)`, `hour(s)`, or `day(s)`.

<Frame>
  <img />
</Frame>

## Digest Strategy Types

The strategy which Novu should use to handle the digest step. More details on available strategies below.

Novu allows you to define different digest strategies depending on the actual use-case you are trying to achieve. At this point we allow you to select from 2 strategies:

* Regular Strategy
* Back-off Strategy

Let's explore them in detail:

#### Regular Strategy

In regular strategy, a digest will always be created for the specified window time. Which means that from the first event trigger, if no active digest exists for this subscriber, one will be created and the user will receive the message only when the digest window time is reached.

#### Back-off Strategy

In the back-off strategy, before creating a digest, Novu will check if a message was sent to the user in the back-off period. If a message was sent, a digest will be created. Otherwise, a message will be sent directly to the user and the digest creation will be skipped.

Backoff digest has two intervals, `digest interval` and `backoff interval`. Here, in the image below, the `digest interval` is `20 minutes`, and the `backoff interval` is `15 minutes`. In the case of a backoff digest, first, it checks if any event is triggered within the past backoff interval, only then a digest is created for the digest interval. If not, the event is considered non-digest and workflow execution continues to the next step.

<Frame>
  <img />
</Frame>

**Example:**

Let's set the digest interval as 20 minutes and the backoff time as 15 minutes.

If we trigger the first event. Since it is the first event and there was no event triggered in the past 15 minutes (backoff interval), this event will be executed as it is (without digest).

Now, if we trigger a second within 15 minutes, then a new digest will be created with this second event. From now onwards till 20 minutes (digest interval), all triggers will be digested in this digest, and after 20 minutes, the workflow will carry forward to the next step with digested events.

## Scheduled Digest

**Minutes:**

It digests events for every specified minutes. For example, as per the image below, events will be digested for 20 minutes and after 20 minutes, workflow will carry forward to the next step. It will be repeated after every 20 minutes.

<Frame>
  <img />
</Frame>

**Hour:**

It digests events for given hours. After given hours, a new digest is created.

<Frame>
  <img />
</Frame>

**Daily:**

It digests events for specified days till given time. After those days and time, a new digest is created and events are digested in this new digest.

<Frame>
  <img />
</Frame>

**Weekly:**

It digests events for specified weekdays. Only at the specified time, the workflow continues to the next step after the digest step. A new digest is created and events are digested in this new digest till these weeks and time.

<Frame>
  <img />
</Frame>

**Monthly:**

<Frame>
  <img />
</Frame>

## Writing digest templates

In many cases, you will need to access all the digested events payload in order to show the user all or parts of the events included in this digest. For example: **"John and 5 others liked your photo."**

As part of the digested template, you will have access to a few properties:

| Property           | Description                                                                                                                                       |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| `step.events`      | An array of all the events aggregated under this digest. This will be the "payload" object passed to each trigger.event sent in the digest period |
| `step.total_count` | The number of total events in this digest                                                                                                         |
| `step.digest`      | A boolean flag to indicate if we are in a digest mode right now                                                                                   |

Let's look at a handlebars syntax example for the following triggers:

```tsx theme={null}
novu.trigger('workflow-name', {
  to: '123',
  payload: {
    name: 'Hello',
  },
});

novu.trigger('workflow-name', {
  to: '123',
  payload: {
    name: 'World',
  },
});
```

After these two triggers, digest variables are as follows:

| Property           | Description                                     |
| ------------------ | ----------------------------------------------- |
| `step.events`      | `[ { "name" : "Hello" }, { "name": "World" } ]` |
| `step.total_count` | `2`                                             |
| `step.digest`      | `true`                                          |

Using the following template:

```HTML theme={null}
Total events in digest:
{{step.total_count}}

{{#if step.digest}}
  {{#each step.events}}
    {{name}}
  {{/each}}
{{else}}
  Not a digested template
{{/if}}
```

It will render as:

`Total events in digest: 2 This is Hello payload event This is World payload event`

<Note> Note that if only one matching trigger activates a regular digest during its period, that single item will still come through as a digest with `step.total_count` as 1. </Note>

### Using subscriber variables

Subscriber variables like `{{subscriber.firstName}}` , `{{subscriber.email}}` etc are system reserved variables. These variables can be used in the same form if used outside of `step.events` iteration. If you want to use subscriber variables inside `step.events` iteration, you can use `{{../subscriber.firstName}}` , `{{../subscriber.email}}`. Reason of this change inside `step.events` iteration is the context change. Subscriber variables are available in the parent context of `step.events` iteration.

```HTML theme={null}
Total events in digest:
{{step.total_count}}
Hey, {{subscriber.firstName}} your id is {{subscriber.subscriberId}}
{{#if step.digest}}
  {{#each step.events}}
    {{name}}
    <br/>
    {{../subscriber.firstName}} your email is {{../subscriber.email}}
  {{/each}}
{{else}}
  Not a digested template
{{/if}}
```

## Event cancellation from Digest

Any event can be cancelled from the Digest via the [event cancellation API](/api-reference/events/cancel-triggered-event) using transactionId of triggered event. For example, if there are 5 events in digest, a user should be able to cancel the **2nd**, **3rd**, or **4th** event before digest time completion.

The cancelled event will not be included in the final digest events array.

## Digest Guides

<CardGroup>
  <Card title="Add Digest to Email Notifications" icon="envelope" href="/guides/add-digest-to-email-notifications">
    Learn how to add digest functionality to email notifications.
  </Card>

  <Card title="Add Digest to In-App Notifications" icon="bell" href="/guides/add-digest-to-inapp-notifications">
    Learn how to add digest functionality to a In-App feed within React app.
  </Card>
</CardGroup>

## Frequently Asked Questions

<Note>All digest times are in UTC time</Note>

<AccordionGroup>
  <Accordion title="If scheduled digest is set for 9:00 AM daily then will the digest be sent at 9:00 AM every day without any event triggered?">
    If scheduled digest is sent for 9:00 daily, then novu will collect all events triggered between 9:00 AM today till 9:00 AM tomorrow and send the digest at 9:00 AM tomorrow. This process is repeated daily. If there is no any event triggered between 9:00 AM today and 9:00 AM tomorrow, then no digest will be sent.
  </Accordion>

  <Accordion title="What is the difference between Regular and Schedules Digest set to 1 Hour?">
    Both digests are same in this case.
  </Accordion>
</AccordionGroup>


# Messages
Source: https://v0.x-docs.novu.co/workflows/messages

Learn about messages in Novu

Each [workflow](/workflows/notification-workflows) has one or more than one step. Each step is either a `channel` (in\_app, email, push, chat) or an `action` (digest, delay).

Within the workflow, every channel has a separate template. Email channel step content can be different than `in_app` channel step content. When a workflow is triggered, Novu generates separate messages for every channel step and sends that message to the recipient.

A triggered event (`notification`) is a collection of step information, its message, and job execution details.

## List messages

Messages can be listed using these SDK methods. These methods support pagination using page and limit field and filters using channel, subscriberId and transactionId field.

<Info>Novu will throw 404 error if requested subscriberId is not a valid subscriberId of any existing subscriber.</Info>

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu, ChannelTypeEnum } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.messages.list({
      page: 0,
      limit: 30,
      channel: ChannelTypeEnum.IN_APP,
      subscriberId: '<SUBSCRIBER_ID>'
      transactionIds: ['transactionId1', 'transactionId2'],
    });
    ```
  </Tab>
</Tabs>

### List messages example response

```javascript theme={null}
{
  "page": 0,
  "totalCount": 987,
  "hasMore": true,
  "pageSize": 30,
  "data": [
    ....
    {
      "cta": {
          "action": {
              "buttons": []
          },
          "type": "redirect",
          "data": {
              "url": ""
          }
      },
      "_id": "messageId",
      "_templateId": "workflowId",
      "_environmentId": "environmentId",
      "_messageTemplateId": "messageTemplateId",
      "_notificationId": "notificationId",
      "_organizationId": "organisationId",
      "_subscriberId": "_subscriberId",
      "_jobId": "jobId",
      "templateIdentifier": "workflowIdentifier",
      "_feedId": "feedId",
      "channel": "in_app",
      "content": "Message Content",
      "deviceTokens": [],
      "seen": false,
      "read": false,
      "status": "sent",
      "transactionId": "d5218a6c-4b08-4617-b176-2d2271f34e42",
      "payload": {
          "key": "value"
          "__source": "test-workflow"
      },
      "expireAt": "2024-06-17T08:18:29.871Z",
      "deleted": false,
      "createdAt": "2023-06-17T08:18:29.871Z",
      "updatedAt": "2023-06-17T08:24:34.888Z",
      "__v": 0,
      "subscriber": {
          "_id": "_subscriberId",
          "subscriberId": "subscriberId",
          "id": "_subscriberId"
      },
      "actorSubscriber": 'actorSubscriberId',
      "id": "messageId"
    }
    ....
  ]
}
```

## Delete a message

A single message can be deleted by messageId using these SDK methods. messageId should be a valid objectId parsed as a string.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    const messageId = '64452b58ec0dbb9e41b4dccf';

    await novu.messages.deleteById(messageId);
    ```
  </Tab>
</Tabs>

### Delete a message example response

```javascript theme={null}
{
  data: {
    acknowledged: true,
    status: 'deleted'
  }
};
```

## API Reference Links

* [List Messages API](/api-reference/messages/get-messages/)
* [Delete a Message API](/api-reference/messages/delete-message/)


# Workflows
Source: https://v0.x-docs.novu.co/workflows/notification-workflows

Here you learn all about workflows

A workflow holds the entire flow of steps (nodes) that are sent to the subscriber. This is where all the different channels are tied together under a single entity.

<Note>
  Notification template has been renamed to workflow. Previously, workflow has been referred to as notification template.
</Note>

## Structure

A workflow acts as the blueprint for the notifications that will be sent. The workflow encapsulates the entire flow and rules of messages that are being sent. This is where all the different channels, filters, rules and actions are tied together under a single entity.

<img />

## Workflow Components

<Steps>
  <Step title="Name and Identifier">
    Every workflow will have a name and an identifier that are used to uniquely identify each workflow.
  </Step>

  <Step title="Trigger">
    The "Trigger" refers to an event or action that initiates the workflow. It signifies a call to the Novu API with a specified workflow ID, along with the necessary payload data that the workflow content will utilize.
  </Step>

  <Step title="Channels">
    In Novu, a channel refers to a preconfigured provider through which notifications are dispatched to recipients. In most instances within Novu, these channels utilize the credentials you provide to ensure the delivery of notifications on your behalf. The combination of these credentials and accompanying settings constitutes a configured channel.

    Within the Novu framework, channels are categorized into various types, each of which is linked with at least one corresponding provider that can be tailored as needed:

    * **Email** (examples include Sendgrid, Postmark)
    * **In-App** (such as feeds, toasts, banners)
    * **Push** (such as APNS, FCM)
    * **SMS** (examples include Twilio, Telnyx)
    * **Chat** (such as Slack, Microsoft Teams, and Discord)
    * **Webhook** (used to send webhooks to custom channels or enable your customers to configure webhooks within your product)
  </Step>
</Steps>

## Execution of Workflow Steps

Once a workflow is initiated by its trigger, the steps (and channels) within the workflow are executed in a specific sequence. This sequential execution ensures that each step is completed before the next one begins, maintaining a controlled and orderly flow of the notification process. Here's what you need to know about this process:

* **Sequential Execution:** Each channel in the workflow is activated one after the other, in the order they are listed within the workflow. This method ensures that each step is given the necessary attention and that dependencies or prerequisites of later steps are adequately met.

* **Order of Channels:** The order in which channels are listed in the workflow is crucial, as it dictates the sequence of their execution. You should carefully consider the order when setting up your workflows to align with your notification strategy.

Sequential execution provides a predictable and reliable workflow process, ensuring that messages are sent out in an organized manner and that each step's output potentially influences the subsequent ones.

<br />

<Warning>Once a workflow is triggered, it can not be changed.
<br /> <br /> Workflow can be canceled only using  [DELETE /events/cancel api](/api-reference/workflows/delete-workflow)</Warning>

<Note>Subscriber is not allowed to manage subscriber preference for [critical workflow](/subscribers/preferences#exclude-workflows-from-preferences-critical-workflow)</Note>

## Workflow Groups

Workflow groups are used to categorize workflows based on their purpose or function. This grouping allows you to organize your workflows in a way that makes sense to you and your team. For example, you may want to group all your onboarding workflows or group all your transactional workflows together. You can create as many groups as you need and assign workflows to them as you see fit.

<Info>Currently workflow group is just for reference purposes and cannot be used for bulk action related to all workflows belonging to a workflow group.</Info>

### Working with workflow groups

**To create a workflow group, follow these steps:**

1. Navigate to the **Workflows** page in the Novu interface.
2. Select any workflow from the list.
3. Click on the **cog** icon on the top right side to open the workflow settings.
4. Stay on the *General* settings tab.
5. Click on the **Workflow Group** dropdown and select the group you want to assign to the workflow.
6. To create a new group start writing some text and a **Create New** option will appear. Click on it to create a new group and select this group for this workflow.
7. Click on the update button on the top right side to save the changes for the entire workflow.

<Frame>
  <img />
</Frame>

To edit a workflow group name, follow these steps:

1. Navigate to the **Settings** page in the Novu interface.
2. Copy the **API Key** from settings (Each environment has a different API Key).
3. Navigate to [API Reference](https://docs.novu.co/api-reference/workflow-groups/get-workflow-groups) page to fetch all workflow groups in Novu documentation.
4. Use the previously copied **API Key** as the **Authorization** header. Make sure it is in the correct format `ApiKey <API_KEY>`
5. Click on the send button to fetch all the workflow groups.
6. In the response field copy the **\_id** field of the workfow group that you want to edit.
7. Use the copied **\_id** as the **path parameter** in the request URL of [workflow update](https://docs.novu.co/api-reference/workflow-groups/update-workflow-group) API using the same **API Key** as the **Authorization** header. Write the new name for the group in the **body** field.
8. Click on the send button to update the workflow group name.

<Info>To delete the workflow group use [delete workflow group api](https://docs.novu.co/api-reference/workflow-groups/delete-workflow-group) with the same steps as updating the workflow group name. However, it is not recommended to delete the workflow group if at least one workflow is attached to this workflow group or there exists a change promotion item on the changes page</Info>

## Searching Workflows

Workflows can be searched by their name or trigger identifier. This feature makes it easy to find the desired workflow and quickly access its details.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## FAQs

<AccordionGroup>
  <Accordion title="Workflow Promotion Error: Notification Group Id Not Found">
    To address the error "Notification Group Id not found" when promoting the workflow from dev to prod, it's essential to check the allocation of a notification group to the workflow. Here is an outlined process to validate:

    <Steps>
      <Step title="Go to the workflow settings in Novu's interface." />

      <Step title="Remain within the general settings tab." />

      <Step title="Check the right-hand side for the notification group dropdown." />

      <Step title="Verify if any group is selected. The group's association will be demonstrated here." />
    </Steps>

    <Tip>New notification group can also be created in the drop-down</Tip>

    If a notification group is not associated, this is likely the cause of the issue. Ensure that the relevant Notification Group Id is assigned in the settings. To do so, you would need to choose one from the drop-down list in the workflow settings .

    <Frame>
      <img />
    </Frame>

    Remember, deleting a workflow is not recommended because it can lead to unexpected behavior like this. Instead, updating the workflow group associated with the specific workflow is the right process to address the issue.
  </Accordion>

  <Accordion title="How to disable a workflow for a single subscriber?">
    When all channels are turned off for that subscriber then subscriber will not receive any messages from any channel step, effectively disabling the workflow for that subscriber.

    2. If you want to make a workflow inactive or active, you can do so through the workflow settings. However, it's important to note that this action will affect **all** subscribers.

    3. To disable a workflow for only one subscriber, you can achieve this by having the subscriber disable all channels for that specific workflow through their subscriber preferences. This action will solely impact that particular subscriber.
  </Accordion>

  <Accordion title="What is the difference between workflowId and trigger identifier?">
    `workflowId` is a MongoDB-generated identifier within the Novu system, serving as a unique identifier for workflows. It cannot be modified or altered once generated. This `workflowId` is utilized in several APIs, including the [GET Workflow API](https://docs.novu.co/api-reference/workflows/get-workflow).

    <img />

    A `trigger identifier` is a distinctive label utilized to activate a workflow, typically represented in a slugified format. Novu generates this identifier automatically based on the workflow's name, and it can be modified at a later time if needed. Currently, our system supports only a single trigger identifier per workflow. However, as part of our future plans, we intend to enable the use of multiple trigger identifiers for a single workflow, each capable of initiating the workflow from different sources.

    <img />

    Hence, while `workflowId` refers to the umbrella structure that holds the entire flow of messages, the `trigger identifier` is the specific event that starts this sequence.
  </Accordion>

  <Accordion title="How does Novu prevent duplicate notifications sent to subscribers?">
    The `transactionId` within Novu is a unique identifier that is used to ensure the idempotent nature of notification delivery.

    When you trigger an event to send a notification, you have the option to provide a `transactionId`. If you do not provide one, Novu will generate a UUID for you.

    **This identifier is particularly useful for preventing the same notification from being sent multiple times in case the trigger event is inadvertently called more than once.**

    By leveraging the `transactionId`, you can make idempotent requests, which means if the same `transactionId` is used in another request, Novu's API will recognize it and will not send the same notification again.

    <Note>
      This upholds the principle of idempotency, ensuring that the effect of the operation is the same, no matter how many times the request is repeated with the same `transactionId`.
    </Note>
  </Accordion>
</AccordionGroup>


# Step Conditions
Source: https://v0.x-docs.novu.co/workflows/step-filters

Learn how to customize your notifications flow in Novu.

Workflow step conditions allow you to customize the flow of notifications in your workflow by specifying criteria for which notifications should be delivered.

You can use these conditions to ensure that only relevant notifications are sent to your subscribers, improving the efficiency and effectiveness of your communication.

<Warning>**Step Conditions** used to be called **Step Filters**.</Warning>

## On Condition

* On `payload`: You can specify a list of keywords or values that the `payload` field must match in order for the notification to be delivered. This is useful if you only want to receive notifications that contain certain information.
* On `subscriber`: You can filter which subscriber should receive notifications based on subscriber information. This means that you can send notifications to specific individuals or groups rather than all subscribers. It checks on subscriber attributes. Read more about [subscriber attributes](https://docs.novu.co/subscribers/subscribers#subscriber-attributes).
* On `webhook`: You can use this feature to provide information about subscribers from specified webhook response and use that information to filter the notification flow. For example, if your webhook returns a field indicating whether a subscriber is currently online, you can use this field to send notifications only to online subscribers.
* On `online right now`: You can filter notifications on the basis of the current online status of the subscriber. For example, You can choose to send a notification if the subscriber is currently online or offline.
* On `online in the last "X" time period`: You can use this to filter notifications for a subscriber if the subscriber was online in the last `X` minutes/hours/days.

### Steps to set Conditions

1. Create a step in your workflow. This step will be the location where you will apply your filter.
2. Add a condition to the step. This will allow you to specify the criteria that must be met for the notification to be delivered.

<Frame>
  <img />
</Frame>

3. If you want to add multiple conditions, you will need to choose a logical condition between `AND` and `OR` . This will determine how the conditions are applied to the notification. For example, if you choose `AND`, the notification will only be delivered if all of the conditions are met. If you choose `OR`, the notification will be delivered if any of the conditions are met.
4. Add a rule to the condition. This will specify the criteria that must be met for the notification to be delivered. You can use the `payload`, `subscriber`, or `webhook` field as the basis for your rule. For example, you might specify that the `payload` field must contain a certain keyword or that the `subscriber` must be in a specific group.

## Condition rule

A condition rule is composed of the following fields:

* **On** : This specifies which field the rule should be applied to, such as `Payload`, `Subscriber`, or `Webhook` response.
* **Key** : This specifies the object key that the rule should be applied to. For example, if the `On` field is `Subscriber`, the `Key` field might be `name`, `email` etc.
* **Operator** : This specifies the comparison operator to use when evaluating the rule. Options include **Equal**, **Not equal** , **Larger** , **Smaller** , **Larger or equal**, **Smaller or equal** , **Contains**, **Not contains** and **Is Defined**.
* **Value** : This specifies the `value` to compare to the object key value using the selected `operator`. The value field also accepts variables.

<Frame>
  <img />
</Frame>

**Example of a condition rule**:

In this condition, the notification will only be delivered if the webhook response includes a field called `isOnline` that is set to `true`.

<Frame>
  <img />
</Frame>

## Conditions with Webhook

To filter notifications based on a webhook response, you will need to create a webhook that accepts POST requests and returns a one-level object. The webhook should be set up to receive object the following parameters:

* **subscriber** - This is an object containing information about the subscriber that the notification is being sent to.
* **payload** - This is an object containing the payload of the trigger that initiated the notification.
* **identifier** - workflow identifier is a unique identifier for the notification template being used.
* **providerId** - provider identifier is a unique identifier for the communication provider you used on this notification.
* **channel** - The channel identifier specifies the type of notification channel that was used to send the notification.

### Securing your webhooks

To secure your webhooks, Novu uses the `nv-hmac-256` header as a security measure.

This header contains an HMAC hash that is calculated based on your `API Key` 
and `Environment Id`, ensuring that the request is coming from Novu.
This helps in protection against unauthorized access and tampering with your webhooks.

To verify the authenticity of the request, you can use the following code:

```jsx theme={null}
import { createHmac } from 'crypto';

const hmacHash = createHmac('sha256', 'NOVU_API_KEY').update('ENVIRONMENT_ID').digest('hex');

if (hmacHash === hmac) {
  // The request is authentic
} else {
  // The request is not authentic
}

```

> **ENVIRONMENT\_ID** can be accessed in the webhook subscriber parameter in the request body. **NOVU\_API\_KEY** can be found in the settings section of the Novu client.

The webhook should return a one-level object containing any information that you want to use to filter the notification flow. For example, you might include a field called `isOnline` having value `true` or `false` that specifies whether the subscriber is currently online or not.

## Subscriber online conditions

This allows you to apply a condition on a workflow step based on the `subscriber's` online status. The condition can be applied to determine if the subscriber is currently online or if the subscriber was online in the **X** time-period.

**Example** : To send an email notification to all subscribers who were active within the last 30 minutes, follow these steps:

* On the Workflow editor page, add an `Email` step after trigger in workflow.
* Click on the email step to edit its content template.
* Click on the  `Add conditions` button from the upper right position.

<Frame>
  <img />
</Frame>

* Click `Add condition` to add a rule.
* Select `Last time was online` and choose `minutes` as the time period.
* Enter `30` in the input field.

<Frame>
  <img />
</Frame>

By applying this condition, the notification will only be delivered to subscribers that were last active in the past 30 minutes, ensuring that the message is reaching engaged and active recipients.

### Online condition mechanism

Novu uses a websocket connection within the `notification-center` package to track the online status of subscribers. The `isOnline` and `lastOnlineAt` fields of the subscriber's entity are updated accordingly.

When a subscriber comes online, an active websocket connection is established with the server. Novu then updates the `isOnline` field of the subscriber's entity to `isOnline: true`. When the subscriber disconnects, Novu updates `isOnline: false` and `lastOnlineAt: current_timestamp`.

The online condition feature can be used to determine if a subscriber is online right now or if the subscriber was online within a specific time period.

* To determine if a subscriber is online right now, Novu checks the value of the `isOnline` field. If `isOnline` is `true`, the subscriber is online, otherwise when the `isOnline` is `false` the subscriber is considered offline.
* To determine if a subscriber was online within a specific time period, Novu compares both the `isOnline` and `lastOnlineAt` fields. If `isOnline` is `true`, the subscriber is still online and the condition is applied. If `isOnline` is `false`, the difference between the `current timestamp` and the `timestamp` value of `lastOnlineAt` is calculated. If this difference is within the specified time period, the subscriber was online within that time period and the condition is applied. Otherwise, the condition is not applied.

For example, to determine if a subscriber has been online in the last 5 minutes, Novu checks if the subscriber is currently online or if the `lastOnlineAt` timestamp value is less than or equal to 5 minutes ago. If either of these conditions are met, the condition is applied.

## Subscriber Seen / Read Conditions

This condition gives the flexibility of executing successive step notifications based on the status of previous step notification. It currently works for in-app and email step notifications.

**Typical Use Case**:

You have a set of customers to whom you need to send a 2-step email. However, they should only get the second email if they have read/seen the first email.

With the seen/read condition, you can do the following in a workflow:

* Set the first email step.
* Set a delay.
* Set the second email step.
* Create a condition on the second email step that indicates if the previous step needs to be seen/read before it should be executed.

<Frame>
  <img />
</Frame>

<Note> For this condition to work with emails, the webhook url needs to be set up for the active `email` provider you're using on Novu. It's very essential for the condition to work. No extra set up is needed for `in-app` notifications. </Note>

## Is Defined Condition

Is Defined condition checks whether specified `key` exists or not. It is different from `Equal` and `Not equal` condition. `Equal` and `Not equal` condition checks whether key value is equal to specified value or not, but `Is Defined` condition just checks whether key is present or not.

<Frame>
  <img />
</Frame>

<Note> This condition can be used with subscriber, payload and webhook. It can be applied on all channels. </Note>

## Monitoring the condition's status inside Activity Feed

To check if the notification sent was conditioned or not, visit the `Activity Feed` page.

* Select the notification you're interested in checking the filter status for.
* A new popup `Execution Details` will open up.

<img />

* Click on the notification step row to open up the details for the corresponding step.
* On this screen, you can monitor the notification status along with filter details if any.

<img />

<Info>Digest variables (step.digest, step.events, step.total\_count) are not supported in step conditions.</Info>


# Template Store
Source: https://v0.x-docs.novu.co/workflows/template-store

Display inline code and code blocks

The Novu dashboard features an integrated template store for workflows, offering a range of ready-to-use options.

From basic alerts to intricate sequences, you can select a template, customize it, and swiftly trigger notifications tailored to your needs.
This streamlined process cuts down development time and empowers you to communicate effectively with minimal effort.

<img />


# Variants
Source: https://v0.x-docs.novu.co/workflows/variants

Learn how to create and use multiple variants for workflow steps in Novu.

Variants is a workflow component that empowers users to create multiple versions of a given workflow step.

You can use variants to ensure that only specific versions of your workflow step (e.g Email) are sent to subscribers. These variants are linked to specific conditions. No variant can exist without a condition.

Variants are an integral component of our [multi-tenancy feature](/tenants/introduction#tenant-specific-notification-content).

## Steps to create Variants

In this case, we'll use a workflow Email step. Let's create multiple variants for this step.

1. Create an email step in your workflow.

<Frame>
  <img />
</Frame>

2. Add a variant to the step as shown below.

<Frame>
  <img />
</Frame>

3. A variant must have conditions set. Add a condition or multiple conditions.

<Frame>
  <img />
</Frame>

In this case, we added a condition (as shown below) to check if the tenant identifier passed at the point of trigger is equal to `edenlife`. This is now a **multi-tenant variant**!

Apply conditions to set it successfully.

<Frame>
  <img />
</Frame>

The variant has been created. Click on the **Update** button.

<Frame>
  <img />
</Frame>

4. Head over to the email step again. You will see two variants: the **root variant** & **v1 variant**. The **v1 variant** is the one where you set the tenant condition while the **root variant** is the default version of the email step without a condition.

<Frame>
  <img />
</Frame>

5. You can add different content to the two variants.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

During the notification sending phase, Novu's logic will determine the appropriate variant based on the contextual information that was passed with the trigger event and the conditions applied to the variants.

In this case, if a tenant identifier with the value of `edenlife` was passed with the trigger event, then Novu will select the v1 variant and send to subscribers.

On the other hand, if the tenant identifier has a different value or was not passed with the trigger event, then Novu will select the root variant and send to subscribers.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
      import { Novu } from '@novu/node';

      const novu = new Novu("<NOVU_API_KEY>");

      await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
        {
          to: {
            subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          },
          payload: {
            name: "Hello World",
          },
          tenant: "edenlife"
        }
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
      use Novu\SDK\Novu;

      $novu = new Novu('<NOVU_API_KEY_HERE>');

      $novu->triggerEvent([
        'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
        'payload' => [
          'name' => 'Hello'
        ],
        'to' => [
            'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
        ],
        'tenant': "edenlife"
      ]);
    ```
  </Tab>
</Tabs>

## Variant Conditions

There are so many use cases for variants. It's not limited to [multi-tenancy](/tenants/introduction#tenant-specific-notification-content).

You can set conditions based on the following data:

* Subscriber
* Payload
* Webhook
* Is online
* Last time was online

### Sample Use Cases

1. If you're looking to send a different type of email based on whether a subscriber is online, then variants are the right choice.

2. If you want to send different types of email to subscribers based on the specific type of payload or subscriber data passed with the trigger event, variants are a good choice!


# Data Migrations
Source: https://v0.x-docs.novu.co/additional-resources/data-migrations

Learn how to update your database data through migrations.

On occasion, Novu may introduce features that require changes to the database schema or data.
This usually happens when a feature has a hard dependency on some data being available on a database entity.
You can use migrations to make these changes to your database.

## Running Migrations

To run data migrations, enter the following sequence of commands in your terminal from the [`novuhq/novu`](https://github.com/novuhq/novu) repository root:

```bash theme={null}
npm run setup:project
cd apps/api
npm run migration -- ./migrations/<MIGRATION_PATH>.ts
# e.g. npm run migration -- ./migrations/add-user-contact/add-user-phone.ts
```

Some features may have multiple migrations, in which case you will need to run each migration in the order shown below.

## Migrations History

Below you will find a list of migrations introduced in previous versions of Novu, alongside the migration path to use in the script above.

| Version                                                      | Feature                 | Migration Path(s)                                                                                                                          |
| ------------------------------------------------------------ | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| [v0.23](https://github.com/novuhq/novu/releases/tag/v0.23.0) | API keys encryption     | `./encrypt-api-keys/encrypt-api-keys-migration.ts`                                                                                         |
| [v0.18](https://github.com/novuhq/novu/releases/tag/v0.18.0) | Multi-Provider          | `./integration-scheme-update/add-primary-priority-migration.ts`<br />`./integration-scheme-update/add-integration-identifier-migration.ts` |
|                                                              | Integration Store       | `./novu-integrations/novu-integrations.migration.ts`                                                                                       |
| [v0.16](https://github.com/novuhq/novu/releases/tag/v0.16.0) | In-App Integration      | `./in-app-integration/in-app-integration.migration.ts`                                                                                     |
|                                                              | Secure Flag Fix         | `./secure-to-boolean/secure-to-boolean-migration.ts`                                                                                       |
| [v0.15](https://github.com/novuhq/novu/releases/tag/v0.15.0) | Database TTL            | `./expire-at/expire-at.migration.ts`                                                                                                       |
| [v0.12](https://github.com/novuhq/novu/releases/tag/v0.12.0) | Organization Invite Fix | `./normalize-users-email/normalize-users-email.migration.ts`                                                                               |
| [v0.9](https://github.com/novuhq/novu/releases/tag/v0.9.0)   | Seen/Read Support       | `./seen-read-support/seen-read-support.migration.ts`                                                                                       |
| [v0.8](https://github.com/novuhq/novu/releases/tag/v0.8.0)   | Secure Credentials      | `./fcm-credentials/fcm-credentials-migration.ts`<br />`./encrypt-credentials/encrypt-credentials-migration.ts`                             |
| [v0.4](https://github.com/novuhq/novu/releases/tag/v0.4.0)   | Change Promotion        | `./changes-migration.ts`                                                                                                                   |


# Glossary
Source: https://v0.x-docs.novu.co/additional-resources/glossary

Definitions

## Introduction

In this section, you’ll find a list of key terms, their definitions and various concepts associated with Novu. Familiarising yourself with these will help you understand and use Novu better. They will help you navigate our docs more effectively and utilise Novu to its maximum potential.

If you have any questions or need further clarification on any of the terms listed above, please feel free to reach out to our support team or join our community!

## List of key terms and definitions

## Notification

A brief message or alert that informs users about events, updates, or some other information

## Channels

Novu lets you send notifications across different communication mediums, including emails, in-app messages, push notifications, SMS, and chat. Each of these five communication mediums is referred to as a notification ‘channel’.

<Frame>
  <img />
</Frame>

## Providers

Providers are responsible for handling message delivery across various channels. Novu currently supports multiple notification channels, each with its own set of providers.

* Chat: This channel offers these providers:
  * Discord
  * MS Teams
  * Slack
  * Zulip
* Email: The Email channel features these providers:
  * Sendgrid
  * Amazon SES
  * Sendinblue
  * Resend
  * SparkPost
  * Postmark
  * Mailjet
  * Mailtrap
  * Plunk
  * Braze
  * Mailersend
  * Outlook 365 (based on a custom SMTP server)
  * Mailgun
  * Mandrill
  * Netcore
  * Infobip, and
  * Custom SMTP
* SMS: The SMS channel features these providers:
  * Twilio SMS
  * SMS77
  * Africa’s Talking
  * Infobip
  * Nexmo
  * Plivo
  * Sendchamp
  * AWS SNS
  * Telnyx
  * Termii
  * Firetext
  * Gupshup
  * Clickatell
  * Azure SMS
  * BulkSMS
  * SimpleTexting
  * MessageBird
* Push Notification Providers: This channel includes these providers:
  * Firebase Cloud Messaging (FCM)
  * Expo Push
  * Apple Push Notification Service (APNS)
  * One Signal
  * Pushpad
  * Pusher Beams
  * Push Webhook
* In-app Notification Center: Novu provides you with a set of APIs and components to create rich customized notification center experiences:
  * React component
  * Angular component
  * Vue component
  * Web component
  * iFrame embed
  * Custom styling
  * Headless notification center

## Subscribers

Subscribers are entities designated to receive the notifications you send. Each subscriber in Novu is uniquely identified by their `subscriberId`.

## Actor

An `actor` refers to a user or subscriber who initiates actions that trigger events within the system. Each actor is uniquely identified by an "actorId," also known as "subscriberId," which distinguishes them from others.

Actors hold user-related variables, such as subscriber properties and data payload, containing information like names, emails, and custom data.

Additionally, actors can enhance notifications by allowing their avatars to be displayed, improving the context and identification of notifications.

Including actors in event data enables precise tracking and personalization of actions and events in the Novu platform.

## Workflow

Workflow templates define the flow of messages sent to subscribers.

## Topics

Topics facilitate bulk notifications to multiple subscribers simultaneously, streamlining communication.

## Digest Engine

The digest engine aggregates multiple trigger events into a single message, ensuring efficient communication.

## Delay Actions

Delay actions introduce time intervals between workflow steps, optimizing message delivery timing.

## Step Filter

Step filters customize workflow by specifying notification criteria, enhancing communication efficiency.

## Organizations

Organizations allow separation of notifications across multiple products, managed through the Novu web dashboard.

<Frame>
  <img />
</Frame>

## Environments

Novu runs all your requests in the context of an environment. By default, Novu creates two environments when your account was created, `development` and `production`.

1. `Development environment`: The development environment is used for testing purposes and validating notification changes prior to committing them to the production environment.
2. `Production environment`: It will be your live/production environment, you cannot make changes to this environment directly. You will first have to make the changes in the `development` environment and then promote it to `production`. This is a read-only environment.

## Data associated with an environment

* Subscribers (can’t be promoted to production)
* Workflows (can be promoted to production)
* Messages
* Execution logs
* Connected integrations (can’t be promoted to production)
* Notification feeds (can be promoted to production)
* Brand-related assets and settings

## Team members

Members of a team have access to the Novu web dashboard. This allows you to have individuals work on and manage templates and notifications.

## Layouts

Layouts are HTML designs or structures to wrap the content of email notifications. Layouts can be manipulated and assigned to new or existing workflows within the Novu platform, allowing users to create, manage, and assign these layouts to workflows, so they can be reused to structure the appearance of notifications sent through the platform.


# Idempotent Requests
Source: https://v0.x-docs.novu.co/additional-resources/idempotency

Retry API requests fearlessly, ensuring the operation performs just once!

Our platform has a seamless integration of optional [idempotent](https://en.wikipedia.org/wiki/Idempotence) requests for `POST` and `PATCH` operations.
This integration closely adheres to the [Idempotency-key ietf draft](https://datatracker.ietf.org/doc/draft-ietf-httpapi-idempotency-key-header/).
These idempotent operations deliver the same result regardless of the number of requests made, using an idempotent key.

Leveraging this feature guarantees the safety and reliability of your requests, especially in cases where network or communication issues might inject uncertainty into request outcomes.
Idempotent requests are <b>critical</b> for workflows that require the insurance of only one successful delivery request.

<Note>
  This feature was introduced in version 0.22.0 and is fully operable from 0.24.0 and beyond. Currently, the Idempotency headers are not enabled on the cloud platform but are available for self-hosting.
</Note>

<Warning>
  Please be aware that idempotency might not be supported in all community SDKs.
</Warning>

## How to Perform an Idempotent Request with SDKs

Supporting SDKS will implement Idempotency for you as long as you have retries turned on.
Not only is this seamless but it also ensures that no event request is dropped provided that your system stays up.

<Note>
  Idempotency is only implemented for /events/trigger endpoint.
</Note>

### Idempotent request with api

To make an idempotent request, simply include the `Idempotency-Key: <key>` in your request header.
This key should be a unique client-generated value, boasting enough entropy to prevent collisions;
we recommend a collision-resistant Unique Identifier, such as UUIDv7, CUID, or ULID, as your idempotency keys.

## Understanding Response Replay

Our API stores the status code and response body from your initial idempotent request.
This way if an identical idempotency key appears in a later request,
the API will replay the saved response from the original request - even if it involves client or server error responses.

In the event of a response replay, the response will carry an `Idempotency-Replay: true` header.

## Idempotent Request Responces

Here are some unique pieces constraints you should be aware of especially if you are not using the sdk:

1. A `<key>` exceeding 255 characters will trigger a `400 Bad Request` error.
2. An inconsistent request body compared to the initial request will return a `422 Unprocessable Entity` error.
3. A ongoing processing of the initial request that hasn't yet responded will result in a `409 Conflict` error. This will include a `Retry-After` header.

<Note>
  Results will <b>not</b> saved if an API request is invalid.
</Note>

## Expiring Keys

All idempotency keys are ensured to be automatically removed once they are 24 hours and 1 minute old.
After this period, the reused key will be treated as a new request and response.

## Practical Examples

### Example 1 - No idempotency

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
      to: {
        subscriberId: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      },
      payload: {
        name: "Hello World",
      },
      actor: "actorId",
      tenant: "tenantIdentifier",
    });
    ```
  </Tab>
</Tabs>

### Example 2 - Idempotency Active

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>", {
        retryConfig: {
            retryMax: 5
        }
    });

    // This request is now idempotent
    await novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
      to: {
        subscriberId: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      },
      payload: {
        name: "Hello World",
      },
      actor: "actorId",
      tenant: "tenantIdentifier",
    });
    ```
  </Tab>
</Tabs>

## References

* [https://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/eo](https://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/eo)


# Blog Posts, Articles & Videos
Source: https://v0.x-docs.novu.co/additional-resources/posts-videos-and-articles

Blog posts, articles, and videos

## Blog Posts / Articles

* [🪄✨Building a blog with a liking feature using React, Hanko and Novu 🔥](https://dev.to/novu/building-a-blog-with-a-liking-feature-using-react-hanko-and-novu-1m81)
* [How to add In-App notifications to any web app!](https://dev.to/novu/how-to-add-in-app-notifications-to-any-web-app-1b4n)
* [How To Add In-App Notifications To Your Angular App](https://dev.to/novu/how-to-add-in-app-notifications-to-your-angular-app-2dp3)
* [Creating A Hot New Food Delivery App with Novu](https://dev.to/novu/creating-a-hot-new-food-delivery-app-with-novu-2e75)

## Videos

* [How to add In-App Notifications to your Web app with Novu](https://www.youtube.com/watch?v=KD8zoUb132k)
* [Subscriber (User) Management & Bulk Import Guide](https://www.youtube.com/watch?v=m5nhYEuz86I\&t=92s)
* [Workflow Optimization with Delay Actions](https://www.youtube.com/watch?v=kCMB-WdbzJo)

## External Resources

* [Simplify configuration management with Novu and Configu](https://configu.com/blog/video-first-steps-with-configu/)
* [Vercel and Novu integration](https://vercel.com/integrations/novu)
* [Novu is building open-source notification infrastructure for developers](https://venturebeat.com/business/novu-is-building-open-source-notification-infrastructure-for-developers/)
* [Novu - An open-source notification infrastructure for developers](https://reactjsexample.com/-f0-9f-9a-80-open-source-notification-infrastructure-for-products/)
* [Novu Tackles Notification Infrastructure Management](https://thenewstack.io/novu-tackles-notification-infrastructure-management/)
* [Novu: Omni-channel notification infrastructure for developers](https://www.decibel.vc/articles/novu-omni-channel-notification-infrastructure-for-developers)


# Discord
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/discord

Learn about how to use Discord provider for chat notifications

When using Discord, you will have to store the integration credentials within the subscriber entity. Discord supports two ways to do this:

1. Using the **Discord Webhook** integration.
2. Using the **Discord Bot** integration.

Right now, Novu only supports the **Discord Webhook** integration. This approach has been because the easiest way to set it up is when you have a predefined destination for where the notifications should be sent. It's particularly useful for notifying a specific channel about updates.

**Quickstart:**

To get started with using Novu’s Discord Webhook integration, you need a ‘webhook token’. Here’s how you can generate the same for testing purposes:

1. Go to the channel you want to add the webhook to (you need to be an admin of the discord server).
2. Right-click the channel and select "Edit Channel".
3. Integrations -> Webhooks -> New Webhook
4. Copy the webhook URL.
5. After obtaining the webhook URL in the previous step, you need to store it within the subscriber entity. Doing this ensures that Novu knows where (in which discord channel) to send the notification to. Here’s how to do it:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Discord, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "discord",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "discord-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum to specify the provider.
* The third parameter is the credentials object. In this case, we use the `webhookUrl` property to specify the webhook URL generated in the previous step.

6. You are all set up and ready to send your first chat message via our `@novu/node` package or directly using the REST API in the channel you chose on your discord server.


# MS Teams
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/ms-teams

Learn about how to use MS Teams provider for chat notifications

MS Teams does not need any `API Key` or `Client ID` to send notifications. Our current implementation is based on the [Incoming Webhook URL](https://learn.microsoft.com/en-us/microsoftteams/platform/webhooks-and-connectors/how-to/add-incoming-webhook?tabs=newteams%2Cjavascript). It is a URL that you can use to send messages to a specific channel. This URL needs to be stored on the subscriber entity

Similar to [Discord](https://www.notion.so/Additional-Resources-65ef4aca5d0f4115947030c2f5705101?pvs=21), the credential for this provider needs to be stored in the [subscriber entity](/api-reference/subscribers/update-subscriber-credentials).

## Creating incoming webhook URL

Checkout step by step instructions on microsoft team's documentation on how to [create an incoming webhook url](https://docs.microsoft.com/en-us/microsoftteams/platform/webhooks-and-connectors/how-to/add-incoming-webhook?tabs=newteams%2Cjavascript).

<Frame>
  <img />
</Frame>

## Storing webhook url on subscriber entity

The URL generated above will be the target channel of a subscriber that you want to integrate with. To make this connection, you have to:

1. Copy the URL that you generated above
2. Update the subscriber credentials with this URL using the MS Teams provider id. You can do this step by using the `@novu/node` library, as shown below:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials(
      'subscriberId', 
      ChatProviderIdEnum.MsTeams, // providerId
      { webhookUrl: "<WEBHOOK_URL>" },
      'msteams-MnGLxp8uy' // integration identifier
    );
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "msteams",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "msteams-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum to specify the provider.
* The third parameter is the credentials object, in this case, we use the `webhookUrl` property to specify the MS Teams channel webhook URL or by calling the `Update Subscriber Credentials` endpoint on Novu API. Check endpoint details [here](https://docs.novu.co/api/update-subscriber-credentials/).

<Info>
  If you are looking to use  provider in different way or your usecase is not covered by this documentation, you can always reach out to our team at [support@novu.co](mailto:support@novu.co) or via [Discord](https://discord.novu.co)
</Info>


# Chat Channel Overview
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/overview

Learn the process of configuring and using chat providers with Novu

Novu can be used to deliver chat messages to your customers using a unified delivery API. You can easily integrate your favorite chat provider using the built-in integration store.

<iframe />

## Configuring chat providers

To configure a chat provider, you need to add a new integration to your Novu account. You can do this by navigating to the integration store and clicking on the **Add a provider** button and then select the chat provider you want to configure. You can find the [integration store](https://web.novu.co/integrations?utm_campaign=docs-chat-overview) in the left sidebar of the Novu dashboard.

Each chat provider requires defferent type of credentials. There are few providers which does not require any credentials example: `Discord`

## Sending chat message

Steps to send a chat message using Novu:-

1. Add a chat provider integration to your Novu account from the integration store. Enter credentials if required and save the integration. Follow corresponding provider documentation to get the required credentials.
2. Create a new subscriber

> Step 2 can be skipped if you already have a subscriber. You can use the `subscriberId` of an existing subscriber.

3. [Update](/channels-and-providers/chat/overview#update-credential-webhookurl) the subscriber credential `webhookUrl` for this provider and integration.

4. Create a new [worklow](/workflows/notification-workflows) or use an existing workflow. Add chat channel and [write content](/content-creation-design/notification-content-creation#chat) for the message.

5. Trigger this workflow to above `subscriberId` using trigger identifier

6. Check the chat provider if message is received. If not, check the logs in [activity feed](/activity-feed/introduction) for for any errors.

## Update credential webhookUrl

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Slack, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "slack",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "slack-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

<Info> Integration identifier is similar to Provider identifier but it is different than Provider Id. It is unique for each integration. You can find the `integrationIdentifier` in the integration store page.  </Info>

## Common errors

Common erros and reason of those errors while sending chat messages using Novu.

1. Subscriber does not have a configured channel.
   * if the subscriber does not have credentials set up for any of the chat provider.
2. Webhook URL for the chat channel is missing.
   * `webhookUrl` field is null, undefined or not set. Check using [get subscriber api](/api-reference/subscribers/get-subscriber).
3. Subscriber does not have an active integration.
   * if subscriber have credentials set but integration is either not active or deleted for this credential.

<Tip>
  <MissingProvider />
</Tip>


# Slack
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/slack

Learn about how to use Slack provider for chat notifications

When using Slack you will have to save the integration credentials in the subscriber entity.

This guide will walk you through the steps needed to obtain the `webhookUrl` that Novu requires to send chat messages to your customers.

We will provide the basic flow that the user needs to perform, to successfully send notifications via the Slack integration.

<Note>We've a [dedicated guide](/guides/slack-guide) on integrating Novu in a Slack app.</Note>

### Creating application

This step is optional, if you already have a Slack application you can reuse it.

1. Go to Slack's developer dashboard [https://api.slack.com/apps](https://api.slack.com/apps).
2. Create a new application.

### Integrating Novu with Slack

There are two ways to integrate Novu with Slack - Novu Managed (recommended) and manually managed. Let’s look at both of them in detail:

### 1. Novu Managed (Recommended)

If you use this approach, then Novu will manage the OAuth flow and store the credentials

1. Configure your Slack application as mentioned [below](#configuring-slack-application).
2. You need to make a network request to the `Shareable URL` to perform authentication.
3. You can find the `Shareable URL` in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integrations-slack)

<Frame>
  <img />
</Frame>

4. You can either add the `Add to Slack` button or use the `Shareable URL` directly, in the application you'll be using Novu in.
   <Info>The network request to the 'Shareable URL' will happen when the user clicks the 'Add to Slack' button.</Info>
5. This is to request permission for access (scope: incoming-webhook).
6. You can use the generated `Shareable URL` that is found under the Slack integration in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integrations-slack). The `Shareable URL` should have the following format:

```bash theme={null}
https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials/slack/oauth?environmentId=<ENVIRONMENT_ID>&integrationIdentifier=<PROVIDER_ID>.

```

* `SUBSCRIBER_ID` is a custom identifier used when identifying your users within the Novu platform.
* `ENVIRONMENT_ID` is a context of an environment you can locate your environment id in the setting in the [dashboard settings](https://web.novu.co/settings?utm_campaign=docs-integrations-slack).
* `PROVIDER_ID` (optional) is a unique identifier of the integration and is required when you have multiple slack integrations in Novu. You can locate your integration identifier in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integratons-slack). When not provided, the last created integration will be used.
  If you are using the `Add to Slack` button you have to provide the `Shareable URL` as the `redirect_uri` parameter like in this example. Make sure that the `Shareable URL` is URL encoded:

```html theme={null}
<a
  href="https://slack.com/oauth/v2/authorize?client_id=CLIENT_ID&scope=incoming-webhook&user_scope=&redirect_uri=https%3A%2F%2Fapi.novu.co%2Fv1%2Fsubscribers%2FSUBSCRIBER_ID%2Fcredentials%2Fslack%2Foauth%3FenvironmentId%3DENVIRONMENT_ID%26integrationIdentifier%3DINTEGRATION_IDENTIFIER"
  ><img
    alt="Add to Slack"
    height="40"
    width="139"
    src="https://platform.slack-edge.com/img/add_to_slack.png"
    srcset="
      https://platform.slack-edge.com/img/add_to_slack.png    1x,
      https://platform.slack-edge.com/img/add_to_slack@2x.png 2x
    "
/></a>
```

7. Either you use the 'add to Slack' button or use the `Shareable URL`, you should land here:

<Frame>
  <img />
</Frame>

8. Then you'll be redirected to the address you chose in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integrations-slack):

<Frame>
  <img />
</Frame>

<Info>You can use the URL of whichever page you want your users to land on, after successful execution</Info>
9\. That's it! Now you can trigger your workflow and send notifications:

<Frame>
  <img />
</Frame>

<Note>Don't forget to check out our [dedicated guide](/guides/slack-guide) on integrating Novu in a Slack app for more.</Note>

### 2. Manually managed

To use the manually managed option, you need to generate a `webhookUrl` and plug it into your backend.

1. Goto 'Incoming Webhooks' in your Slack app settings and turn it on.

<Frame>
  <img />
</Frame>

2. Click on the 'Add New Webhook to Workspace':

<Frame>
  <img />
</Frame>

3. Now, go ahead and select the channel in which you want to send notifications and click 'allow'.

<Frame>
  <img />
</Frame>

4. Then, copy the 'webhookUrl' from Slack.

<Frame>
  <img />
</Frame>

5. Now, you need to save the `webhookUrl` on the relevant subscriber entity in Novu. Here's an example to do the same using our Node SDK:

## Update credential webhookUrl

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Slack, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "slack",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "slack-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum.Slack if you’re using Node, else string of Slack to specify the provider.
* The third parameter is the credentials object. In this case, we use the `webhookUrl` property to specify the webhook URL generated in the previous step.

6. You are all set up and ready to send your first chat message via our @novu/node package or directly using the REST API.

## Configuring Slack application

1. Go to OAuth & Permissions on Slack's Developer Dashboard and add your REDIRECT\_URL in Redirect URLs.
   * If you use a manual Management solution, add the API endpoint you created in Step 1.
   * If you use the Novu Managed solution add `https://api.novu.co/v1/subscribers`.
2. Go to Incoming Webhooks from the left menu and Activate Incoming Webhooks.
3. Go to Manage Distribution and at the bottom of the page, tick Remove Hard Coded Information and Activate Public Distribution.

### Enabling HMAC Encryption

To enable Hash-Based Message Authentication Codes, you need to do the following steps:

1. Visit the integration store page and enable HMAC encryption under your chat provider.

2. The next step would be to generate an HMAC encrypted subscriberId on your backend:

   ```jsx theme={null}
   import { createHmac } from 'crypto';

   const hmacHash = createHmac('sha256', process.env.NOVU_API_KEY)
     .update(subscriberId)
     .digest('hex');

   ```

3. Add the newly created hash HMAC to the Sharable URL as a query.

This concludes the Slack provider guide.


# How to send WhatsApp Business notifications with Novu
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/whats-app

Learn about how to use WhatsApp for chat notifications

## Getting Started

To integrate WhatsApp Business with Novu, You will have to create a facebook developer app and obtain the necessary credentials.

### Step 1: Create a Facebook Developer App

Visit the [Facebook Developer Portal](https://developers.facebook.com/apps/) and create a new app.

Select "Other" for "What do you want your app to do?" and select "Business" for "Select an app type".

### Step 2: Setup WhatsApp Product

On the App Setup page, click on "Set Up" under the "WhatsApp" product. You will need to create or add a Facebook Business Account to your app.

### Step 3: Send a Sandbox Message

Copy the following pieces and paste them in the Novu WhatsApp Business integration settings:

* Temporary Access Token - Access API token Field
* Phone Number ID - Phone Number Identification Field

<Warning>
  It's important to note that the test credentials for whatsapp cannot be used in production and will expire in 24 hours.
  You will need to submit your app for review to obtain production credentials.
</Warning>

### Step 4: Add a Test Phone Number

You can add a test phone number to the sandbox by clicking on the "Add Phone Number" button.
This number can be used to test your integration with Novu before submitting for a review.

### Step 5: Send a test notification from Novu

You can now create a new Workflow with a "Chat" node, and add your content. Save your workflow, and click on "Trigger Notification" Button.

In the to field, specify the phone number you added in the sandbox, and click on "Send Notification".

```json theme={null}
{
  "subscriberId": "TEST_SUBSCRIBER_ID",
  "phone": "+11111111111"
}
```

and in the `overrides` field, add the following:

```json theme={null}
{
  "chat": {
    "template": {
      "name": "hello_world",
      "language": {
        "code": "en_US"
      }
    }
  }
}
```

<Info>
  For test credentials you can only used the built in Whats App Template.
</Info>

## Going to Production

### Register a Business Phone Number

To go live you will need to add a real business phone number and submit your app for review.
Follow the [Facebook Instructions](https://developers.facebook.com/docs/whatsapp/cloud-api/get-started/add-a-phone-number) on how to proceed.

### Generate a permanent access token

Follow the [Facebook Instructions](https://developers.facebook.com/docs/whatsapp/business-management-api/get-started/) on how to generate a permanent access token.
Depending on your use case.

### Create a WhatsApp Template

You will need to create a WhatsApp Template to send notifications to your customers. Create a template in the [Business Manager](https://business.facebook.com/wa/manage/message-templates) and submit it for review.
After your template is approved, you can use the `template_name` to send notifications to your customers.

To send a notification with a template, you will need to add the following to the `overrides` field:

```typescript theme={null}
novu.trigger('workflow-id', {
    to: {
        subscriberId: "SUBSCRIBER_ID",
        phone: "+11111111111"
    },
    payload: {},
    overrides: {
        chat: {
            template: {
                name: "template_name",
                language: {
                    code: "en_US"
                }
            }
        }
    }
})
```


# Zulip
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/zulip

Learn about how to use Zulip provider for chat notifications

Zulip does not need any API Key or client ID to push messages in it. All it needs is the webhook URL of the channel you want to send messages to. That itself acts as the credential.

Similar to Discord, the credential for this provider needs to be stored in the subscriber entity.

## Getting a Zulip webhook URL

* Sign up or Login to your Zulip account.

* Click on the Settings icon in the top right corner of the screen, and then click "Personal settings" from the drop-down menu.

<Frame>
  <img />
</Frame>

* Click "Add a new bot" button in "Bots" tab.

<Frame>
  <img />
</Frame>

* Set bot type as "Incoming webhook".

<Frame>
  <img />
</Frame>

* Click the small link icon to generate webhook URL for provider. Set Integration as `Slack compatible webhook`, choose your channel and copy webhook URL.

<Frame>
  <img />
</Frame>

## Connecting our subscribers to Zulip

The URL generated above will be the target channel of a subscriber that you want to integrate with. To make this connection, you have to:

1. Copy the URL that you generated above

2. Update the subscriber credentials with this URL using the Zulip provider id. You can do this step by using the `@novu/node` library, as shown below:

## Update credential webhookUrl

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Zulip, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "zulip",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "zulip-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum to specify the provider.
* The third parameter is the credentials object, in this case, we use the `webhookUrl` property to specify the MS Teams channel webhook URL or by calling the `Update Subscriber Credentials` endpoint on Novu API. Check endpoint details [here](https://docs.novu.co/api/update-subscriber-credentials/).

3. You are all set up and ready to send your first chat message via our `@novu/node` package or directly using the REST API.


# Custom SMTP
Source: https://v0.x-docs.novu.co/channels-and-providers/email/custom-smtp

Learn how to use the Custom SMTP provider to send email notifications using Novu

You can use a Custom SMTP provider like [Nodemailer](https://nodemailer.com/about/) to send transactional emails through your custom SMTP server to your customers using the Novu Platform with a single API.

# Getting Started

To use the Custom SMTP provider in the email channel, you will need to have your personal SMTP server configured and add `host`, `port`, `user`, and `password` to the Custom SMTP integration on the Novu platform.

You can also provide value **`true`** for the `secure` field if you want the connection to be secure, and if not, leave it empty.

### DKIM (DomainKeys Identified Mail)

DKIM options can be used in order to sign messages sent using Custom SMTP with DKIM keys.

Those options are:

* `DKIM Domain`
* `DKIM Private Key`
* `DKIM Key Selector`

# Creating a Custom SMTP integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-customsmtp) page on Novu.
* Click on Add a Provider.
* Select Custom SMTP service.
* Enter your SMTP credentials
  * `host`
  * `port`
  * `username`
  * `password`
  * `secure` (on demand)
  * And `DKIM` options if you want to sign messages with *DKIM*
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Custom SMTP in Novu.


# Plunk
Source: https://v0.x-docs.novu.co/channels-and-providers/email/plunk

Learn how to use the Plunk provider to send email notifications using Novu

You can use the [Plunk](https://useplunk.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Plunk provider in the email channel, you will need to create a Plunk account and add your API key to the Plunk integration on the Novu platform.

## Get API Key

To generate a new API key in Plunk, you can follow these steps:

* Log in to your Plunk account.
* Click on `Project Settings` on the side bar and then `API keys` on the tab.
* On the API Keys page, click on `Secret API key` to copy.

## Authenticate your sender identity

Before you can send emails on a large scale, you will need to authenticate your Sender Identity. Plunk allows you to authenticate your sender identity using [Domain Authentication](https://app.useplunk.com/settings/identity)

## Create a Plunk integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-plunk) page on Novu.
* Click on Add a Provider.
* Select Plunk service.
* Enter your Plunk secret API Key.
* Fill the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Plunk in Novu.


# Resend
Source: https://v0.x-docs.novu.co/channels-and-providers/email/resend

Learn how to use the Resend provider to send email notifications using Novu

You can use the [Resend](https://resend.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Resend provider in the email channel, you will need to create a Resend account and add your API key to the Resend integration on the Novu platform.

# Generating an API Key

To generate a new API key in Resend, you can follow these steps:

* [Sign up](https://resend.com/secret) or [Log in](https://resend.com/login) to your Resend account.
* Click on the **API Keys** link in the left sidebar, and then click the "Create API Key" button on the top right part of the page.
* On the [API Keys](https://resend.com/api-keys) page, click the **Create API Key** button.
* Give the API key a name and click on the **Add** button.
* Copy the generated API Key.

# Authenticating your Sender Identity

Before you can send emails on a large scale, you will need to authenticate your Sender Identity.

Resend allows you to authenticate your sender identity using [Domain Authentication](https://resend.com/docs/dashboard/domains/introduction).

# Creating a Resend integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-resend) page on Novu.
* Click on Add a Provider.
* Select Resend service.
* Enter your Resend API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
  * For testing, you can use `onboarding@resend.dev` if you have not authenticated your sender identity.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Resend in Novu.


# SendGrid
Source: https://v0.x-docs.novu.co/channels-and-providers/email/sendgrid

Learn how to use the Sendgrid provider to send email notifications using Novu

You can use the [SendGrid](https://sendgrid.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Sendgrid provider in the email channel, you will need to create a Sendgrid account and add your API key to the SendGrid integration on the Novu platform.

## Generating an API Key

To generate a new API key in SendGrid, follow these steps:

* Log in to your SendGrid account.
* Click on the **Settings** gear icon in the top right corner of the screen, and then click "API Keys" from the drop-down menu.
* On the API Keys page, click the **Create API Key** button.
* Give the API key a name and select the following permissions
* **Mail Send** - Full Access
* (Optional) Template Engine - Read Only
* Click the **Create & View** button to generate the API key. The key will be displayed on the screen, but you will only be able to view it once, so make sure to save it in a safe place.

NOTE

The access level of the key will determine what actions the API Key can take, so please choose the correct one.

* **Mail Send** - Full Access
* (Optional) Template Engine - Read Only

## Authenticating your [Sender Identity](https://docs.sendgrid.com/for-developers/sending-email/sender-identity)

Before you can send emails on a large scale, you will need to authenticate your Sender Identity. This is due to the latest regulatory changes regarding SPAM rules and email fraud. Most of the providers including Sendgrid require you to authenticate your Sender Identity before you can send emails.

SendGrid allows you to authenticate your sender identity using one of the following methods:

* [Single Sender Verification](https://docs.sendgrid.com/ui/sending-email/sender-verification) - This is the easiest way to authenticate your sender identity.
* [Entire Domain Authentication](https://docs.sendgrid.com/ui/account-and-settings/how-to-set-up-domain-authentication) - This is recommended if you are sending emails from multiple accounts under your domain.

## SendGrid integration with Novu

* Visit the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-sendgrid) on the Novu web dashboard.
* Click on Add a Provider.
* Select SendGrid service.
* Enter your SendGrid API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications through SendGrid using Novu.

## Using SendGrid template

Novu has its own email editor for writing email template. If you want to use pre made template from SendGrid, you can use `customData` filed of email overrides to send template details. Make sure your `Api Key` has enough permission to read and process the template.

<Info>customData override is available from version 0.21.0</Info>

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.trigger("workflowIdentifier", {
      to: "subscriberId",
      payload: {},
      overrides: {
        email: {
          customData: {
            // sendgrid template templateId
            templateId: 'sendgrid-template-id',
            // sendgrid template variables
            dynamicTemplateData: {
              total: '$ 239.85',
              items: [{
                  text: 'New Line Sneakers',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png',
                  price: '$ 79.95',
                },
                {
                  text: 'Old Line Sneakers rlfjrjrh4hr4rh4',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png',
                  price: '$ 79.95',
                },
              ],
              receipt: true,
              name: 'Sample Name',
              address01: '1234 Fake St.',
              address02: 'Apt. 123',
              city: 'Place',
              state: 'CO',
              zip: '80202',
            },
          },
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl --location 'https://api.novu.co/v1/events/trigger' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <NOVU_API_KEY>' \
    --data '{
        "name": "workflowIdentifier",
        "to":  ["subscriberId"],
        "payload": {},
        "overrides": {
            "email": {
                "customData": {
                    "templateId": "sendgrid-template-id",
                    "dynamicTemplateData": {
                        "total": "$ 239.85",
                        "items": [
                            {
                                "text": "New Line Sneakers",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png",
                                "price": "$ 79.95"
                            },
                            {
                                "text": "Old Line Sneakers rlfjrjrh4hr4rh4",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png",
                                "price": "$ 79.95"
                            }
                        ],
                        "receipt": true,
                        "name": "Sample Name",
                        "address01": "1234 Fake St.",
                        "address02": "Apt. 123",
                        "city": "Place",
                        "state": "CO",
                        "zip": "80202"
                    }
                }
            }
        }
    }'
    ```
  </Tab>
</Tabs>


# Sendinblue
Source: https://v0.x-docs.novu.co/channels-and-providers/email/sendinblue

Learn how to use the Sendinblue provider to send email notifications using Novu

You can use the [Sendinblue](https://www.sendinblue.com/) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the Sendinblue provider in the email channel, you will need to create a Sendinblue account and add your API key to the Sendinblue integration on the Novu platform.

# Finding the API Key

* To find your Sendinblue API key, log into your Sendinblue account and navigate to the [API Keys](https://account.sendinblue.com/advanced/api) page.

# Authenticating your sender identity

Before you can send emails on a large scale, you will need to authenticate your sender's identity. This is due to the latest regulatory changes regarding SPAM rules and email fraud. Most of the providers including Sendinblue require you to authenticate your sender identity before you can send emails.

Sendinblue allows you to authenticate your sender identity using one of the following methods:

* [Single Sender Verification](https://account.sendinblue.com/senders) - This is the easiest way to authenticate your sender identity.
* [Entire Domain Authentication](https://help.sendinblue.com/hc/en-us/articles/115000185270-What-is-a-verified-domain-on-Sendinblue-) - This is recommended if you are sending emails from multiple accounts under your domain.

# Creating a Sendinblue integration with Novu

* Visit the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-sendinblue) on the Novu web dashboard.
* Click on Add a Provider.
* Select Sendinblue service.
* Enter your Sendinblue API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Sendinblue in Novu.

## Using Sendinblue template

Novu has its own email editor for writing email template. If you want to use pre made template from Sendinblue, you can use `customData` filed of email overrides to send template details. Make sure your `Api Key` has enough permission to read and process the template.

<Info>customData override is available from version 0.21.0</Info>

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.trigger("workflowIdentifier", {
      to: "subscriberId",
      payload: {},
      overrides: {
        email: {
          customData: {
            // sendinblue template templateId
            templateId: 1,
            // sendinblue template variables
            templateParams: {
              total: '$ 239.85',
              items: [{
                  text: 'New Line Sneakers',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png',
                  price: '$ 79.95',
                },
                {
                  text: 'Old Line Sneakers rlfjrjrh4hr4rh4',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png',
                  price: '$ 79.95',
                },
              ],
              receipt: true,
              name: 'Sample Name',
              address01: '1234 Fake St.',
              address02: 'Apt. 123',
              city: 'Place',
              state: 'CO',
              zip: '80202',
            },
          },
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId",
      tenant: "tenantIdentifier"
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl --location 'https://api.novu.co/v1/events/trigger' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <NOVU_API_KEY>' \
    --data '{
        "name": "workflowIdentifier",
        "to":  ["subscriberId"],
        "payload": {},
        "overrides": {
            "email": {
                "customData": {
                    "templateId": 1,
                    "templateParams": {
                        "total": "$ 239.85",
                        "items": [
                            {
                                "text": "New Line Sneakers",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png",
                                "price": "$ 79.95"
                            },
                            {
                                "text": "Old Line Sneakers rlfjrjrh4hr4rh4",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png",
                                "price": "$ 79.95"
                            }
                        ],
                        "receipt": true,
                        "name": "Sample Name",
                        "address01": "1234 Fake St.",
                        "address02": "Apt. 123",
                        "city": "Place",
                        "state": "CO",
                        "zip": "80202"
                    }
                }
            }
        }
    }'
    ```
  </Tab>
</Tabs>


# Sparkpost
Source: https://v0.x-docs.novu.co/channels-and-providers/email/sparkpost

Learn how to use the Sparkpost provider to send email notifications using Novu

You can use the [SparkPost](https://messagebird.com/email/cloud-sending) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the SparkPost provider in the email channel, you will need to create a SparkPost account and add your API key to the SparkPost integration on the Novu platform.

# Generating an API Key

To generate a new API key in SparkPost, you can follow these steps:

* [Sign up](https://app.sparkpost.com/join) or [Log in](https://app.sparkpost.com/auth) to your SparkPost account.

  > During sign up, note that SparkPost is available in multiple regions. "SparkPost" refers to the SparkPost service hosted in North America. "SparkPost EU" refers to the SparkPost service hosted in Western Europe. An account created with SparkPost cannot be used with SparkPost EU, and vice-versa. You may use accounts in both regions.
  >
  > \~ *[SparkPost Documentation](https://support.sparkpost.com/docs/getting-started/getting-started-sparkpost/)*
* Click on the **Configuration** link on the navbar, and then click the "API Keys" link that pops up from the available options.
* On the [API Keys](https://app.sparkpost.com/account/api-keys) page, click the **Create API Key** button.
* Give the API key a name and click on the **Create API key** button.
* Copy the generated API Key.

# Authenticating your Sender Identity

Before you can send emails on a large scale, you will need to authenticate your Sender Identity.

SparkPost allows you to authenticate your sender identity using [Sending Domains](https://app.sparkpost.com/domains/list/sending).

# Creating a SparkPost integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sparkpost) page on Novu.
* Click on Add a Provider.
* Select SparkPost service.
* Enter your SparkPost API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Toggle the `eu` switch to true if you're in Western Europe
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using SparkPost in Novu.


# Apple Push Notification Service (APNS)
Source: https://v0.x-docs.novu.co/channels-and-providers/push/apns

Learn how to use the Apple Push Notification Service (APNS) provider to send push notifications using Novu

[Apple Push Notification Service](https://docs.expo.dev/push-notifications/overview/), as the name suggests, is a notification delivery service provided by Apple.

Apple provides two authentication methods to make a secure connection to APNs. The first is Certificate-Based Authentication (using a .p12 certificate). The second is Token-Based Authentication (using a .p8 key). We'll make use of the **.p8** key.

To enable APNS integration, you need to create an [Apple Developer](https://developer.apple.com/) account with an [Admin role](https://appstoreconnect.apple.com/access/users).

To generate the p8 key for your account:

1. Head over to **Certificates, Identifiers & Profiles > Keys**.
2. Register a new key and give it a name.
3. Enable the Apple Push Notifications service (APNs) checkbox by selecting it.
4. Click the **Continue** button and on the next page, select **Register**.
5. Download the **.p8** key file.

You also need the following to connect to APNs:

1. **Key ID** - This is a 10-character unique identifier for the authentication key. You can find it in the key details section of the newly created key in your Apple developer account.
2. **Team ID** - This is available in your Apple developer account.
3. **Bundle ID** - This is the ID of your app. You can find it in the app info section of your Apple developer account.

The overrides field supports all [Notification payload](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/generating_a_remote_notification?language=objc) values, as shown below:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    abc: 'def', // If the notification is a data notification, the payload will be sent as the data
  },
  overrides: {
    apns: {
      payload: {
        aps: {
          notification: {
            title: 'Test',
            body: 'Test push',
          },
          data: {
            key: 'value',
          },
        },
      },
    },
  },
});
```

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    key1: 'val1',
    key2: 'val2', // If the notification is a data notification, the payload will be sent as the data
  },
  overrides: {
    type: 'data',
    apns: {
      headers: {
        'apns-priority': '5',
      },
      payload: {
        aps: {
          alert: {
            'loc-key': 'GAME_PLAY_REQUEST_FORMAT',
            'loc-args': ['Shelly', 'Rick'],
          },
          sound: 'demo.wav',
        },
      },
    },
  },
});
```

Before triggering the notification to a subscriber(user) with push as a step in the workflow, make sure you have added the subscriber's device token as follows:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.APNS, {
      deviceTokens: ['token1', 'token2'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "apns",
      "deviceTokens": ["token1", "token2"],
      "integrationIdentifier": "apns-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.


# Expo Push
Source: https://v0.x-docs.novu.co/channels-and-providers/push/expo-push

Learn how to use the Expo push provider to send push notifications using Novu

[Expo Push](https://docs.expo.dev/push-notifications/overview/) is a notification delivery service provided by Expo.

To enable Expo Push integration, you need to create an [Expo Application Services (EAS)](https://expo.dev/)account and generate an access token in the EAS dashboard.

The overrides field supports all [Message Request](https://docs.expo.dev/push-notifications/sending-notifications/#message-request-format) values. An example of the same follows:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    abc: 'def',
  },
});
```

Before triggering the notification to a subscriber(user) with push as a step in the workflow, make sure you have added the subscriber's device token as follows:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,PushProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.EXPO, {
      deviceTokens: ['token1', 'token2'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "expo",
      "deviceTokens": ["token1", "token2"],
      "integrationIdentifier": "expo-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.


# Firebase Cloud Messaging (FCM)
Source: https://v0.x-docs.novu.co/channels-and-providers/push/fcm

Learn how to use the Firebase Cloud Messaging (FCM) provider to send push notifications using Novu

[Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging) is a free notification delivery service provided by Google Firebase.

To enable the FCM integration, you need to get your service account key from the [Firebase Console](https://console.firebase.google.com/).

## Generating a Service Account Key JSON

To acquire the account key JSON file for your service account

1. Select your project, and click the gear icon on the top of the sidebar.
2. Head to project settings.
3. Navigate to the service account tab.
4. Click **Generate New Private Key,** then confirm by clicking **Generate Key.**
5. Clicking **Generate Key** downloads the JSON file.

After that, paste the entire JSON file content in the Service Account field of the FCM provider in the integration store on Novu’s web dashboard.

Make sure your service account json content contains these fields

```json theme={null}
{
  "type": "service_account",
  "project_id": "PROJECT_ID",
  "private_key_id": "PRIVATE_KEY_ID",
  "private_key": "PRIVATE_KEY",
  "client_email": "FIREBASE_ADMIN_SDK_EMAIL",
  "client_id": "CLIENT_ID",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "CLIENT_X509_CERT_URL"
}
```

## FCM Overrides

The overrides field supports apns, android, webpush and fcmOptions overrides

| Override Field | Type / Interface | Link                                                                                                                                                                                         |
| -------------- | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| android        | AndroidConfig    | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.androidconfig](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.androidconfig) |
| apns           | ApnsConfig       | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.apnsconfig](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.apnsconfig)       |
| webPush        | WebpushConfig    | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.webpushconfig](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.webpushconfig) |
| fcmOptions     | FcmOptions       | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.fcmoptions](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.fcmoptions)       |

## Setting Device Token

Before triggering the notification to a subscriber(user) with push as a step in the workflow, make sure you have added the subscriber's device token as follows:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      PushProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials(
      'subscriberId', 
      PushProviderIdEnum.FCM, 
      { deviceTokens: ['token1', 'token2'] }, 
      'fcm-MnGLxp8uy'
    );
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "fcm",
      "credentials": {
        "deviceTokens" : [
          "token1", 
          "token2"
        ]
      },
      "integrationIdentifier": "fcm-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

## SDK Trigger Example

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
  to: {
    subscriberId: "<SUBSCRIBER_ID>",
  },
  payload: {
    abc: "def", // If the notification is a data notification, the payload will be sent as the data
  },
  overrides: {
    fcm: {
      // type: 'data' => will turn this into an FCM data notification, where the payload is sent as a data notification. If the type is not set, you can use the "data" override to send notification messages with optional data payload
      type: "data",

      // URL of an image to be displayed in the notification.
      imageUrl: "https://domain.com/image.png",

      // If type is not set, you can use the "data" override to send notification messages with optional data payload
      data: {
        key: "value",
      },

      // Check FCM Overrides section above for these types
      android: {},
      apns: {},
      webPush: {},
      fcmOptions: {},
    },
  },
});
```

Device/notification identifiers can be set by using [setCredentials](#set-device-token) or by using the `deviceIdentifiers` field in overrides.

<Info> Novu uses FCM version V1</Info>

## Relative Link in Webpush

Suppose you’re using the Firebase (FCM) provider to send push notifications to web browsers via Novu and want users to be returned to the website after clicking the notification.

In that case, you must use the `link` property with a relative URL.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from "@novu/node";

    const novu = new Novu("<NOVU_API_KEY>");

    novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
      to: {
        subscriberId: "<SUBSCRIBER_ID>",
      },
      payload: {
        abc: "def", // If the notification is a data notification, the payload will be sent as the data
      },
      overrides: {
        fcm: {
          webPush: {
            fcmOptions: {
              link: "/foo",
            },
          },
        },
      },
    });
    ```
  </Tab>

  <Tab title="Curl">
    ```bash theme={null}
    curl --location --request POST 'https://url.to.our.selfhosted.novu' \
        --header 'Authorization: ApiKey KEY' \
        --header 'Content-Type: application/json' \
        --data-raw '{
            "name": "workflow-name",
            "to": {
                ...
            },
            "overrides": {
              "fcm": {
                "webPush": {
                  "fcm_options": {
                    "link": "/foo"
                  }
                }
              }
            }
          }'
    ```
  </Tab>
</Tabs>

## FCM Cost

As per Firebase [pricing](https://firebase.google.com/pricing), **Cloud Messaging** product is free of cost to use. If other Firebase products are used, the cost will be charged as per the product.

## FAQs

<AccordionGroup>
  <Accordion title="The registration token is not a valid FCM registration token">
    You may come across an error like so:

    ""Sending message failed due to "The registration token is not a valid FCM registration token""".

    This error happens because of invalid or stale token. The fix for this is to remove old tokens, generate a new token and save it into user subscribers.
  </Accordion>

  <Accordion title="FCM notifications sent successfully with no error but push notification is not received in device">
    Try to generate a new token after clearing device cache and retry with this fresh token.
  </Accordion>

  <Accordion title="Sending message failed due to 'Requested entity was not found'">
    This error occurs when your token is no longer valid. To fix this, generate a new token and use it.
  </Accordion>

  <Accordion title="Subscriber does not have a configured channel error">
    This error occurs if the fcm integration is active but subscriber is missing from the fcm credentials (deviceTokens). The credentials (deviceTokens) for the subscriber needs to be set.
  </Accordion>
</AccordionGroup>


# Onesignal
Source: https://v0.x-docs.novu.co/channels-and-providers/push/onesignal

Learn how to use the Onesignal provider to send push notifications using Novu

[OneSignal](https://onesignal.com/) is a paid push notification service that supports sending messages via both [Apple Push Notification Service](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server) (APNs) as well as [Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging) (FCM).

To configure the OneSignal integration, you will need an active account which has credentials for APNs, FCM or both, and have access to the `OneSignal App ID` and `Rest API Key` available via your [application's settings page](https://documentation.onesignal.com/docs/keys-and-ids).

# Setting the Device Token

Once OneSignal has been configured with your credentials for APNs/FCM, and the OneSignal SDK has been [set up and configured](https://documentation.onesignal.com/docs/onboarding-with-onesignal#step-1-setup-onesignal-sdk) for your application, your users will begin to be automatically assigned a unique OneSignal [player\_id](https://documentation.onesignal.com/docs/users#player-id) identifier by the SDK.

This identifier allows targeting your user when sending push notifications without having to retrieve the specific Android or iOS device tokens - which are managed by OneSignal.

In order to target the OneSignal user from Novu, you must register the OneSignal `player_id`as the `deviceToken` for your Novu subscriber. This value can be retrieved via the [OneSignal SDK](https://documentation.onesignal.com/docs/users-and-devices#finding-users) for your platform.

Once you have the user's `player_id` value, the `deviceToken` for your Novu subscriber can be set via:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.OneSignal, {
      // Your user's unique 'player_id' from OneSignal
      deviceTokens: ['ad0452ca-3ca7-43b5-bf9b-fa93fd322035'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "one-signal",
      "deviceTokens": ["ad0452ca-3ca7-43b5-bf9b-fa93fd322035"],
      "integrationIdentifier": "one-signal-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

# SDK Trigger Example

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    abc: 'def', // If the notification is a data notification, the payload will be sent as the data
  },
});
```

Device/notification identifiers can be set by using [setCredentials](https://docs.novu.co/channels/email/resend/#set-device-token) or by using the `deviceIdentifiers` field in overrides.


# Push Channel Introduction
Source: https://v0.x-docs.novu.co/channels-and-providers/push/overview

Learn how to send push notifications with Novu using external providers like FCM, Expo etc.

Push notifications are short, targeted messages delivered to a user's device or browser, often through mobile apps or websites. They serve as a powerful communication tool, offering real-time updates, reminders, and personalized content. Push notifications can range from news alerts and social media updates to promotional offers and important app notifications.

These messages are designed to engage users and keep them informed about relevant events or activities, even when they are not actively using an app or browsing a website. They play a crucial role in user engagement and retention for businesses and organizations, as they can re-engage users and prompt them to take specific actions.

Novu can be used to deliver push notifications to your customers devices using a unified delivery API. Both Mobile and Web push notifications are supported.

## Using push channel with Novu

To send a push notification to subscribers (users) using Novu:

* Add a push channel provider in integration store
* Add push channel as a step in existing or new workflow.
* Add static or dynamic content using variables in push step fields
* Store provider specific device tokens/identifiers in subscriber profile. Read provider specific documentation on how to obtain and store device tokens.
* Make sure all provider specific steps are configured properly before triggering workflow. Read provider related documentation for all required steps.
* Trigger the workflow.

## Supported providers

* [Firebase Cloud Messaging (FCM)](/channels-and-providers/push/fcm)
* [Expo Push](/channels-and-providers/push/expo-push)
* [Apple Push Notification Service](/channels-and-providers/push/apns)
* [OneSignal](/channels-and-providers/push/onesignal)
* [Pushpad](/channels-and-providers/push/pushpad)
* [Push Webhook](/channels-and-providers/push/push-webhook)

<Note>Novu supports multiple active providers for push channel.</Note>

<Tip>
  <MissingProvider />
</Tip>

## Managing push device tokens

To send push notifications to subscribers, you need to store device tokens or identifiers in subscriber profiles. These tokens are unique identifiers that help push notification providers deliver messages to the correct devices. Each provider has its own method for obtaining and storing device tokens.

Novu offers to ways of keeping your device tokens in sync with subscriber profiles:

* Just-in-time: Pass device tokens in the payload when triggering a workflow. Novu will automatically update subscriber profiles with the new device tokens.
* Manual: Update subscriber profiles with device tokens using the Novu Set Credentials API.

### Just-in-time

When triggering a workflow, you can pass the `channels` array on the subscriber object with the device tokens for the push provider of your choice. Here is an example with fcm:

```typescript theme={null}
novu.trigger('workflow-id', {
  to: {
    subscriberId: 'subscriber-id',
    channels: [
      {
        providerId: 'fcm',
        credentials: {
          deviceTokens: ['token-1', 'token-2'],
        },
      },
    ],
  },
  payload: {},
});
```

### Manual

Use the Novu Set Credentials API to update subscriber profiles with device tokens. You can read more about the API in the [API Reference](/api-reference/subscribers/update-subscriber-credentials) or the [FCM Example](/channels-and-providers/push/fcm#setting-device-token)

## Frequently Asked Questions

### How to remove one device token from subscriber credentials?

To remove a device token from subscriber credentials, you need to get the current device tokens from subscriber credentials, remove all deviceTokens, remove the token you want to remove and then update the subscriber credentials with new device tokens.

<Tabs>
  <Tab title="Node.js">
    ```ts theme={null}
    import { Novu, PushProviderIdEnum } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    // fetch subscriber details
    const subscriber = await novu.subscribers.get('subscriberId');

    // get current device tokens from subscriber credentials for the provider
    const currentDeviceTokens = subsciber.data.data.channels.find(
        // _integrationId can also be checked in place of providerId ;
        (channel) => channel.providerId === PushProviderIdEnum.FCM,
    ).credentials.deviceTokens;

    // remove all device tokens
    await this.novu.subscribers.setCredentials(
        'subscriberId',
        PushProviderIdEnum.FCM,
        { deviceTokens: [] },
    );

    // remove the token you want to remove
    const newDeviceTokens = currentDeviceTokens.filter(
        (token) => token !== 'token-to-be-removed',
    );

    // update subscriber credentials with new device tokens
    await this.novu.subscribers.setCredentials(
        'subscriberId',
        PushProviderIdEnum.FCM,
        { deviceTokens: newDeviceTokens },
    );
    ```
  </Tab>
</Tabs>


# Push Webhook
Source: https://v0.x-docs.novu.co/channels-and-providers/push/push-webhook

Learn how to use the Push Webhook provider to send  notifications using Novu

Push Webhook provider is a bit different different from other push providers as it does not depend on other third party services.
Users can use their own api url as webhook url and novu will make a post request on that webhook url.

## Steps To Configure

1. Go to [integration store](https://web.novu.co/integrations?utm_campaign=docs-push-webhook) and click on `Add a provider` button. Choose `Push` channel and then `Push Webhook` provider.
2. Enter your Webhook URL. For quick testing use [this](https://webhook.site/) website.
3. Enter Secret Hmac Key. Novu will use this secret hmac key to encrypt the data using `HMAC SHA256` algorithm and send the hash as value of `x-novu-signature` header. User can use `x-novu-signature` header to test authenticity of the request. Read more [here](#checking-authenticity)
4. Click on the update button.
5. Update the subscriber credentials using SDK or API. Read more [here](#set-device-token)

<Info>Your webhook url should accept `POST` request.</Info>

## Set Device Token

This step is a mandatory step. Other push providers have third party dependencies where a device token can be generated. But in case of push webhook provider, there is no any way to generate device token. Any random string can be used as device token.

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    // PushProviderIdEnum.PushWebhook = push-webhook
    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.PushWebhook, {
      deviceTokens: ['ANY_RANDOM_STRING'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "push-webhook",
      "deviceTokens": ['ANY_RANDOM_STRING'],
      "integrationIdentifier": "push-webhook-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

## Example paylod sent by novu to webhook url

```json theme={null}
{
  "target": [
    "subscriber-token-for-push-webhook-provider"
  ],
  "title": "Push Webhook message title",
  "content": "push Webhook content body",
  "overrides": {
    "data": {
      "custom_message": "this is custom message from payload push webhook demo",
    }
  },
  "payload": {
    "custom_message": "this is custom message from payload push webhook demo",
    "__source": "test-workflow",
    "subscriber": {
      // subscriber fields
      "_id": "65c0d71c0959a38e8857b131",
      "_organizationId": "organizationId",
      "_environmentId": "environmentId",
      "firstName": "Pawan",
      "lastName": "Jain",
      "phone": "+123456789",
      "subscriberId": "push-webhook-demo-subscriber-id",
      "email": "pawan+push+web+hook+demo@domain.com",
      "channels": [
        {
          "credentials": {
            "deviceTokens": [
              "subscriber-token-for-push-webhook-provider"
            ]
          },
          "_integrationId": "integrationId",
          "providerId": "push-webhook"
        }
      ],
      "data": {
        // custom data field of subscriber
        "isDeveloper": "true"
      },
      "deleted": false,
      "createdAt": "2024-02-05T12:39:56.379Z",
      "updatedAt": "2024-02-05T12:54:08.684Z",
      "__v": 0,
      "id": "65c0d71c0959a38e8857b131"
    },
    "step": {
      // digest variables
      "digest": false,
      "events": [],
      "total_count": 0
    }
  }
}
```

## Checking Authenticity

```typescript theme={null}
import crypto from "crypto"

// secret key added in step 3
const secretKey = "YOUR_HMAC_SECRET_KEY"

// function to handle webhook url route request
async acceptNovuPushWebHookRequest(request, response){

  const payloadSentByNovu = request.body
  const hmacHashSentByNovu = request.headers['x-novu-signature']

  const actualHashValue = crypto
    .createHmac('sha256', secretKey)
    .update(payloadSentByNovu, 'utf-8')
    .digest('hex');

  if(hmacHashSentByNovu === actualHashValue){
    // handle the notification
    console.log("Request sent by Novu")
  } else {
    throw new Error("Not a valod request")
  }
}
```


# Pusher Beams
Source: https://v0.x-docs.novu.co/channels-and-providers/push/pusher-beams

Learn how to use the Pusher Beams provider to send push notifications using Novu

[Pusher Beams](https://pusher.com/beams/) is a cross-platform push notification API service provided by Pusher.

To enable Pusher Beams integration, you need to create a Pusher Beams Instance and use both `Instance ID` and `Secret Key` from the Instance [dashboard](https://dashboard.pusher.com/beams/).

# Setting the Device Token

Once Pusher Beams instance has been created, and the Pusher Beams SDK has been [set up and configured](https://pusher.com/docs/beams/reference/all-libraries/) for your application, you can associate users with their devices using [Authenticated Users](https://pusher.com/docs/beams/guides/publish-to-specific-user/web/).

This identifier allows targeting your user when sending push notifications without having to retrieve the specific Web, Android or iOS device tokens - which are managed by Pusher Beams.

In order to target the Pusher Beams user from Novu, you must register the Pusher Beams Authenticated Users with their `userId` as the `deviceToken` for your Novu subscriber. This value can be retrieved via [getUserId()](https://pusher.com/docs/beams/reference/web/#getuserid) method from the SDK for your platform.

Once you have the user's `userId` value, the `deviceToken` for your Novu subscriber can be set via:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.PusherBeams, {
      // Your user's unique 'userId' from Pusher Beams
      deviceTokens: ['userId-from-pusher-beams'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "pusher-beams",
      "deviceTokens": ['userId-from-pusher-beams'],
      "integrationIdentifier": "pusher-beams-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

# SDK Trigger Example

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    custom_data: 'custom_data', // the payload will be sent as notification data object. Cannot contain the key “pusher”
  },
});
```


# Pushpad
Source: https://v0.x-docs.novu.co/channels-and-providers/push/pushpad

Learn how to use the Pushpad provider to send web push notifications using Novu

[Pushpad](https://pushpad.xyz) is a web push service that supports sending notifications to all major browsers (Chrome, Firefox, Edge, Safari, etc.) via FCM, Mozilla autopush, Windows Push Notification Services and Apple Push Notification service, with just one simple API.

To configure the Pushpad integration, you will need an active account and you need to have a `Pushpad Auth Token` (from the [account settings](https://pushpad.xyz/access_tokens)) and the `Pushpad Project ID` (from the project settings).

# Setting the Device Token

Once Pushpad has been configured with your credentials and the Pushpad SDK has been [set up and installed](https://pushpad.xyz/docs/pushpad_pro_getting_started) on your website, you can [assign a user ID (uid)](https://pushpad.xyz/docs/identifying_users) to the push subscriptions.

This identifier (`uid` or `user ID`) allows targeting a specific browser when sending push notifications.

In order to target the Pushpad user from Novu, you must register the Pushpad `uid` as the `deviceToken` for your Novu subscriber. For example, if you invoked the [Pushpad JavaScript SDK](https://pushpad.xyz/docs/javascript_sdk_reference) with `pushpad('uid', 'user123')`, then `user123` is the user ID for that browser.

Once you have the `uid` value, the `deviceToken` for your Novu subscriber can be set using this code:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.Pushpad, {
      // the user ID (uid) that you used for Pushpad
      deviceTokens: ['user123'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "pushpad",
      "deviceTokens": ['user123'],
      "integrationIdentifier": "pushpad-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

# SDK Trigger Example

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {}
});
```

The devices of the subscriber that should receive the notifications can be set by using `setCredentials` or by using the `deviceIdentifiers` field in overrides.


# Africa's Talking
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/africas-talking

Learn how to use the Africa's Talking provider to send sms notifications using Novu

You can use [Africa's Talking](https://africastalking.com/) provider to send SMS messages to your customers using the Novu platform with a single API to create multi-channel experiences.

## Getting Started

To use Africa's Talking provider in the SMS channel, the first step is to create an Africa's Talking account and add your `API Key`, `username` and `Sender's ID` to Africa's Talking integration on the Novu platform.

## Creating a username

You’ll need to create an application to create a username in Africa’s Talking. To do so, follow the steps below:

* [Sign up](https://account.africastalking.com/auth/register) or [Log in](https://account.africastalking.com/auth/login) to your Africa's Talking account.
* Select the team you want your app to be in.

<Frame>
  <img />
</Frame>

* If you're a new user and don't have a team yet, you'll have to do so by clicking on New Team and entering your team name. Click on Save when you're done.

<Frame>
  <img />
</Frame>

* On the page that appears, click on the Create App button.
* On the pop-up that appears, enter your application name, username and select a country. Then click Save. The `username` is what you will use on the Novu platform.

<Frame>
  <img />
</Frame>

## Generating an API key

To generate a new API key, you can follow these steps:

<Note>
  Ensure you have created an app in your team.
</Note>

* Click on the app you created.

<Frame>
  <img />
</Frame>

* On the page that appears, click on Settings(on the menu on your left). This will display a dropdown. Click on API Key from the dropdown options.

<Frame>
  <img />
</Frame>

* On the page that appears, enter your password and click Generate.

<Frame>
  <img />
</Frame>

* Copy the API Key generated and paste it into the Novu platform or record it somewhere safe for later use because you will not see it from the dashboard on subsequent visits.

<Note>
  Once you've generated your API Key, wait about 3 minutes before testing it.
</Note>

## Getting your Sender's ID

Sender IDs allow you to brand your messages as you send them to your customers. There are two kinds of sender IDs, **shortcodes** and **alphanumerics**. The difference is that you can send and receive messages with shortcodes but only send messages with an alphanumeric.

To create a Short Code:

* On your app dashboard, click on SMS (on the menu on your left). This will display a dropdown. Click on `Shortcodes` from the dropdown options. This will also display a dropdown from which you can then click on `My Shortcodes` to view your codes.

<Frame>
  <img />
</Frame>

* If you have not created one yet, on the `Shortcodes` dropdown option, click on `Request`.
  On the page that appears, fill in the form and submit.

<Frame>
  <img />
</Frame>

## To create an Alphanumeric:

* On your app dashboard, click on SMS (on the menu on your left). This will display a dropdown. Click on `Alphanumerics` from the dropdown options. This will also display a dropdown from which you can then click on `My Alphanumerics` to view your codes.

<Frame>
  <img />
</Frame>

* If you have not created one yet, on the `Alphanumerics` dropdown option, click on `Request`.
  On the page that appears, fill in the form and submit

<Frame>
  <img />
</Frame>

* Once you're done, add either your short code or alphanumeric to the `from` field on the Novu platform.

## Creating an Africa's Talking integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-africastalking) page on Novu.
* Click the "Add a provider" button.
* Locate **Africa's Talking** under the SMS section and click on the **Connect** button.
* Enter the `API key`.
* Fill in the `username` field.
* Fill in the `from` field. This is your registered `short code` or `alphanumeric` value.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using Africa's Talking in Novu.


# AWS SNS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/aws-sns

Learn how to use the AWS SNS provider to send sms notifications using Novu

You can use the [AWS SNS](https://aws.amazon.com/sns/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To integrate AWS SNS on the Novu platform, you will need to have in AWS, an IAM user who has the `sns:Publish` permission.

# Create User

To create a user, log in to AWS Console and follow these steps:

* Go to the `IAM` service page.
* Create a new user with `sns:Publish` permission, or add `sns:Publish` permission to an existing user.
* Add the `Access Key` credential to the user and copy the `Access key ID` and the `Secret access key`.

For security reasons, it is suggested that you create a new User to use with Novu.

# Create an AWS SNS integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-sns) page on Novu.
* Click the "Add a provider" button.
* Locate **Amazon SNS** and click on the **Connect** button.
* Enter your `Access Key ID`, `Secret Access key`, and `AWS region`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Save** button.
* You should now be able to send SMS notifications using **Amazon SNS** in Novu.


# Azure SMS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/azure

Learn how to use the Azure SMS provider to send sms notifications using Novu

You can use the [Azure SMS](https://learn.microsoft.com/en-us/azure/communication-services/quickstarts/sms/send?tabs=windows\&pivots=platform-azcli) SMS provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use Azure SMS provider in the SMS channel, the first step is to create an Azure account and grab the communication services connection string from your account dashboard.

# Creating a Azure SMS integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-azure) page on Novu.
* Click the "Add a provider" button.
* Locate **Azure Sms** under the SMS section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `Connection string`.
* Enter the `From` value.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **Azure Sms** in Novu.


# BulkSMS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/bulk-sms

Learn how to use the BulkSMS provider to send sms notifications using Novu

You can use the [BurstSMS](https://bulksms.com/) provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use BulkSMS provider in the SMS channel, the first step is to create a BulkSMS account and create an [API token](https://www.bulksms.com/account/#!/advanced-settings/api-tokens).

# Creating a BulkSMS integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-bulksms) page on Novu.
* Click the "Add a provider" button.
* Locate **BulkSMS** under the SMS section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `API Token`.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **BulkSMS** in Novu.


# Clickatell
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/clickatell

Learn how to use the Clickatell provider to send sms notifications using Novu

You can use the [Clickatell](https://www.clickatell.com/) provider to send SMS messages to your customers using the Novu Platform.
Let's see how to do it:

## Getting Started

To use the [Clickatell](https://www.clickatell.com/) provider in the SMS channel, the first step is to [create a Clickatell account](https://www.clickatell.com/sign-up/) and add your API key to the Clickatell integration on the [Novu web dashboard](https://web.novu.co/integrations?utm_campaign=docs-sms-clickatell).

## Retrieving your API Key

To find your Clickatell API key:

* [Sign up](https://www.clickatell.com/sign-up/) or [Login](https://app.clickatell.com/signin) to your Clickatell account.
* Click on the `My Workspace`, and then click `SMS` in Channels Section.

<Frame>
  <img />
</Frame>

* Click on the `New SMS Setup`.

<Frame>
  <img />
</Frame>

* Select `API` then `Messaging Type` and click Next.

<Frame>
  <img />
</Frame>

* Select `Basic HTTP API` then `create a new HTTP API` and click Next.

<Frame>
  <img />
</Frame>

* Now fill in all details and Click Next.

<Frame>
  <img />
</Frame>

* Copy the API key and click complete.

<Frame>
  <img />
</Frame>

## Create a Clickatell integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-clickatell) page on Novu.
* Click the "Add a provider" button.
* Locate **Clickatell** under the SMS section and click on the **Connect** button.
* Enter your Clickatell API Key.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Clickatell** in Novu.


# Firetext
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/firetext

Learn how to use the firetext provider to send sms notifications using Novu

You can use the [firetext](https://www.firetext.co.uk) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the firetext provider in the SMS channel, the first step is to create a firetext account and add your API key and Sender ID to the firetext integration on the Novu platform.

* Note : Firetext is only available in uk region. Others may require additional verification.

## Retrieving your API Key

To find your firetext API key:

* [Sign up](https://app.firetext.co.uk/signup) or [Login](https://app.firetext.co.uk/) to your firetext account.
* Click on the `Settings` icon in the top right corner of the screen.

<Frame>
  <img />
</Frame>

* Now Click on the `API` in `My Settings` Section.

<Frame>
  <img />
</Frame>

* On the API Keys page, copy the `API key`.

<Frame>
  <img />
</Frame>

## Create a firetext integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-firetxt) page on Novu.
* Click the "Add a provider" button.
* Locate **firetext** under the SMS section and click on the **Connect** button.
* Enter your `firetext` API Key.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **firetext** in Novu.


# gupshup
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/gupshup

Learn how to use the gupshup provider to send sms notifications using Novu

You can use the [gupshup](https://www.gupshup.io/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the gupshup provider in the SMS channel, the first step is to create a gupshup account and add the Account Username and Password to the gupshup integration on the Novu platform.

# What is User id and Password?

* `userid` : The account number provided by the Enterprise SMS GupShup.
* `Password` : Password is provided by Gupshup for authentication of user id. The password must be the same as used to log on to the Enterprise SMS GupShup website.

# Creating a gupshup integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-gupshup) page on Novu.
* Click the "Add a provider" button.
* Locate **gupshup** under the SMS section and click on the **Connect** button.
* Enter the `User id`.
* Enter the `Password`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **gupshup** in Novu.


# Infobip - SMS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/infobip

Learn how to use the Infobip provider to send sms notifications using Novu

You can use the [Infobip](https://www.infobip.com/developers/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Infobip provider in the SMS channel, you will need to create an Infobip account and add your API key and Base URL to the Infobip integration on the Novu platform.

## Retrieving your API Key

To Find a new API key in Infobip, you can follow these steps:

* [Sign up](https://www.infobip.com/signup) or [Log in](https://portal.infobip.com/login/) to your Infobip account.
* On the [Homepage](https://portal.infobip.com/homepage/), you'll see your API key.

<Frame>
  <img />
</Frame>

Alternatively, you can find the API key on the Developer Tools page.

* On the sidebar (on the left), click on `Developer Tools`.
* This will display a dropdown from which you can then click on `API Ksys` to view your API key.

<Frame>
  <img />
</Frame>

If you want to create an API key:

* Click on the `CREATE API KEY` button
* Fill the form
* Click on `GENERATE`

<Frame>
  <img />
</Frame>

## Finding the Base URL

To see your base URL, log in to the account. Once logged in, on the Homepage, you should see your base URL in this format: `xxxxx.api.infobip.com`.

<Frame>
  <img />
</Frame>

## Create an Infobip integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-infobip) page on Novu.
* Click the "Add a provider" button.
* Locate **Infobip** under the SMS section and click on the **Connect** button.
* Enter your Infobip API Key.
* Enter your Base URL.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

You should now be able to send SMS notifications using Infobip in Novu.


# MessageBird
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/messagebird

Learn how to use the messagebird provider to send sms notifications using Novu

You can use the [MessageBird](https://www.messagebird.com) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the MessageBird provider in the SMS channel, the first step is to create a [MessageBird account](https://www.messagebird.com/en/sign-up) and then generate an `Access Key` within the developers' section section of your MessageBird account. This access key is essential for authenticating your requests to the MessageBird API.

# Creating a MessageBird integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-messagebird) page on Novu.
* Click the "Add a provider" button.
* Locate **MessageBird** under the SMS section. Click it and the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `Access Key` value.
* Enter the `From` value.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **MessageBird** in Novu.


# Nexmo
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/nexmo

Learn how to use the Nexmo provider to send sms notifications using Novu

You can use the [Nexmo By Vonage](https://www.vonage.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Nexmo provider in the SMS channel, the first step is to create a Nexmo account and add the API key and API Secret to the Nexmo integration on the Novu platform.

# Finding the API key and secret

First, [sign up for a Vonage account](https://ui.idp.vonage.com/ui/auth/login) if you don't already have one, and make a note of your API key and secret on the [dashboard getting started page](https://dashboard.nexmo.com/getting-started-guide).

# Create a Nexmo integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-nexmo) page on Novu.
* Click the "Add a provider" button.
* Locate **Nexmo** under the SMS section and click on the **Connect** button.
* Enter the `API key` and `API Secret`.
* Enter a valid `From` email address.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.
* Now it is possible to send SMS notifications using **Nexmo** in Novu.


# SMS Channel Overview
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/overview

Learn the process of configuring and using sms providers with Novu

Novu can be used to deliver sms messages to your customers using a unified delivery API. You can easily integrate your favorite sms provider using the built-in integration store.

<iframe />

## Configuring SMS providers

When creating a SMS provider integration you will be asked to provide additional fields alongside the provider-specific credentials:

* **From** - Will be displayed as the sender of the SMS

Additional credentials can be API key, username, password or other provider specific credentials.

<Note>
  Some countries have strict restriction of using verified `from` sender id
  (name). Kindly check country and provider specific requirements first.
</Note>

## Sending SMS Overrides

The overrides field supports a `sms` property and `from`, `to`, `content` field overrides. This allows you to send a message to a different recipient, from a different sender, or with a different content.

```javascript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  }
  overrides: {
    sms: {
      to: '+123012345678',
      from: 'Novu Team',
      content: 'This SMS message is from overrides'
    },
  },
});
```

## Using different SMS integration

In Novu integration store, multiple SMS channel type provider integrations can be active at the same time. But only one provider integration can be primary at a time. This primary integration will be used as a provider to deliver the SMS by default. If you want to use a different active provider integration then you can use the `integrationIdentifier` sms overrides field.

If there are 4 active SMS integrations with these identifiers:-

1. twilio-abcdef
2. twilio-ghijkl
3. firetext-abcdef
4. infobip-abcdef

Here, if `twilio-abcdef` is primary integration and you want to use `infobip-abcdef` with this trigger then you can use `integrationIdentifier` sms overrides field as below:-

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        sms: {
          integrationIdentifier: "infobip-abcdef"
        },
      },
    });
    ```
  </Tab>
</Tabs>

<Info> Integration identifier is similar to Provider identifier but it is different than Provider Id. It is unique for each integration. You can find the `integrationIdentifier` in the integration store page.  </Info>

## Common errors

Common errors and reason for these errors while sending sms messages using Novu.

1. Subscriber does not have a configured channel.
   * if the `from` field is missing / null / undefined.

<Tip>
  <MissingProvider />
</Tip>


# Plivo
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/plivo

Learn how to use the Plivo provider to send sms notifications using Novu

You can use the [Plivo](https://www.plivo.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Plivo provider in the SMS channel, the first step is to create a Plivo account and add the Account SID and Auth token to the Plivo integration on the Novu platform.

# Finding the Account SID and Auth token

[Sign up](https://console.plivo.com/accounts/register/) or [Login](https://console.plivo.com/accounts/login/) to your Plivo account, and make a note of your Account SID and Auth token on the [Plivo console page](https://console.plivo.com/dashboard/).

# Creating a Plivo integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-plivo) page on Novu.
* Click the "Add a provider" button.
* Locate **Plivo** under the SMS section and click on the **Connect** button.
* Enter the `Account SID`.
* Enter the `Auth token`.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Plivo** in Novu.


# Sendchamp
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/sendchamp

Learn how to use the Sendchamp provider to send sms notifications using Novu

You can use the [Sendchamp](https://www.sendchamp.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Sendchamp provider in the SMS channel, the first step is to create a Sendchamp account and add your API key and Sender ID to the Sendchamp integration on the Novu platform.

## Retrieving your API Key

To find your Sendchamp API key:

* [Sign up](https://my.sendchamp.com/signup) or [Login](https://my.sendchamp.com/login) to your Sendchamp account.
* Click on the Avatar icon in the top right corner of the screen, and then click `API & Integrations` from the drop-down menu.

<Frame>
  <img />
</Frame>

Alternatively, you can access the API key from the Accounts menu.

* Scroll to the bottom of the sidebar (on the left) and click on `Accounts`.
* This will display a dropdown from which you can then click on `API keys & Webhooks` to view your API key.

<Frame>
  <img />
</Frame>

* On the API Keys page, copy the Public access key.

<Frame>
  <img />
</Frame>

## Get your Sender's ID

The Sender ID represents the sender of the message to your customers.

To get your Sender's ID:

* On the sidebar (on the menu on your left), click on `SMS`. This will display a dropdown. Click on `Sender ID` from the dropdown options.
* On the page that appears, you'll find a list of your Sender IDs

<Frame>
  <img />
</Frame>

If you have not created one yet:

* Click on the `Create Sender ID` button to request a Sender ID.
* Fill in the form.
* Click on `Add Sender ID` button.

<Frame>
  <img />
</Frame>

Once it is approved, you can use your Sender ID as the from field on the Novu platform.

## Create a Sendchamp integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-sendchamp) page on Novu.
* Click the "Add a provider" button.
* Locate **Sendchamp** under the SMS section and click on the **Connect** button.
* Enter your Sendchamp API Key.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Sendchamp** in Novu.


# SimpleTexting
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/simpletexting

Learn how to use the SimpleTexting provider to send sms notifications using Novu

You can use the [SimpleTexting](https://simpletexting.com/) SMS provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use SimpleTexting provider in the SMS channel, the first step is to create a SimpleTexting account and grab your `API KEY` in your settings.

# Creating a SimpleTexting integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-simpletexting) page on Novu.
* Click the "Add a provider" button.
* Locate **SimpleTexting** under the SMS section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `API Key`.
* Enter the `From` value.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **SimpleTexting** in Novu.


# SMS77
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/sms77

Learn how to use the SMS77 provider to send sms notifications using Novu

It is possible to use the [SMS77](https://www.sms77.io/en) provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the SMS77 provider in the SMS channel, the first step is to create an SMS77 account and add the personal API key to the SMS77 integration on the Novu platform.

# Find the API key

To find the SMS77 API key, log into the personal SMS77 account and navigate to the API Keys page by clicking on the 'Developer' tab present at the end of the sidebar. It is suggested to create a new API key for use with Novu. Copy the newly created API key.

# Creating an SMS77 integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-sms77) page on Novu.
* Click the "Add a provider" button.
* Locate **SMS77** under the SMS section and click on the **Connect** button.
* Enter the `API key`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Save** button.
* Now it is possible to send SMS notifications using **SMS77** in Novu.


# Telnyx
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/telnyx

Learn how to use the Telnyx provider to send sms notifications using Novu

You can use the [Telnyx](https://telnyx.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Telnyx provider in the SMS channel, you will need to create a Telnyx account and add your API key to the Telnyx integration on the Novu platform.

# Finding the API Key

To find your Telnyx API key:

* Log into your Telnyx account.
* Navigate to Account Setting.
* Then go to [Keys & Credentials](https://portal.telnyx.com/#/app/api-keys).
* You can copy the API key from there.
* Alternatively, you can create an API key by tapping on the Create API Key button.

Before copying it, make sure its status is showing active.

# Finding the Message Profile ID

To get your Message profile ID:

* Navigate to [Messaging](https://portal.telnyx.com/#/app/messaging) to find the profiles.
* Make sure you created a Telnyx Messaging Profile previously. Learn more [here](https://developers.telnyx.com/docs/v2/messaging/quickstarts/portal-setup).
* Go to the active Messaging Profile.
* Copy the profile ID.

# Making sure that the From address is valid

A valid from address must be a valid phone number in +E.164 format, a short code, or an alphanumeric sender ID associated with the sending messaging profile. Alphanumeric sender IDs must be between 1 and 11 characters long, and can only contain ASCII letters, numbers, and spaces. They must contain at least one letter.

# Creating a Telnyx integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations) page on the Novu.
* Click the "Add a provider" button.
* Locate Telnyx and click on the **Connect** button.
* Enter your Telnyx API Key.
* Fill in the Message profile ID field.
* Enter the Valid From address.
* Click on the `Disabled` button and `mark it as Active`.
* Click on the **Save** button.
* You should now be able to send notifications using Telnyx in Novu.


# Termii
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/termii

Learn how to use the Termii provider to send sms notifications using Novu

You can use the [Termii](https://termii.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Termii provider in the SMS channel, the first step is to create a Termii account and add your API key and Sender ID to the Termii integration on the Novu platform.

## Retrieving your API Key

To find your Termii API key:

* [Sign up](https://accounts.termii.com/#/register) or [Login](https://accounts.termii.com/#/login) to your Termii account.
* Navigate to your [dashboard](https://accounts.termii.com/#/).
* Then scroll to the bottom of the page to find your API key.

<Frame>
  <img />
</Frame>

Alternatively, you can find the API key on the Settings page.

* Scroll to the bottom of the sidebar (on the left) and click on settings.
* This will display a dropdown from which you can then click on `API Token` to view your API key.

<Frame>
  <img />
</Frame>

## Getting your Sender's ID

Sender IDs allow you to brand your messages as you send them to your customers.

To get your Sender's ID:

* On the sidebar (on the menu on your left), click on `Rental`. This will display a dropdown. Click on `SMS Sender IDs` from the dropdown options.
* On the page that appears, you'll find a list of your Sender IDs

<Frame>
  <img />
</Frame>

If you have not created one yet:

* Click on the `Make a new request` button to request a Sender ID.
* Fill in the form
* Click on `Save`

<Frame>
  <img />
</Frame>

## Creating a Termii integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations) page on Novu.
* Click the "Add a provider" button.
* Locate **Termii** under the SMS section and click on the **Connect** button.
* Enter your Termii API Key.
* Fill in the `From` field.
* Click on the Disabled button and mark it as Active.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Termii** in Novu.


# Twilio
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/twilio

Learn how to use the Twilio provider to send sms notifications using Novu

You can utilize the [Twilio](https://www.twilio.com/) API to communicate with your customers using SMS messaging. Let’s look at how you can do that:

# Setting up Twilio

1. First, go to [Twilio](https://www.twilio.com/) and create an account, probably starting with their free trial.
2. You’ll be asked to verify your email and your phone number. Get them verified.
3. Once you’re done with that, you’ll get an option to ‘get a Twilio phone number’ from your Twilio console.
4. Click on it to get your Twilio phone number.

When first using Twilio there should be an option to get a Twilio phone number in the main console. Otherwise, you may have to [Buy](https://console.twilio.com/us1/develop/phone-numbers/manage/search?frameUrl=%2Fconsole%2Fphone-numbers%2Fsearch%3Fx-target-region%3Dus1\&currentFrameUrl=%2Fconsole%2Fphone-numbers%2Fsearch%3FisoCountry%3DUS%26searchTerm%3D%26searchFilter%3Dleft%26searchType%3Dnumber%26x-target-region%3Dus1%26__override_layout__%3Dembed%26bifrost%3Dtrue) a number from that link to begin using it. Assuming this is the first run though, utilize the free number given to us.

Simply follow one of their many [Tutorials](https://www.twilio.com/docs/usage/requests-to-twilio) within their docs to understand every part of the process.

Irrespective of the language you use, the process is the same:

* Load the Account SID and Auth token into the code, using some sort of safe environment such as .env variables. Nobody should have access to this but you.
* Create a client object from Twilio that take the SID and Token as variables then create a message with the client.
* A message is an object that has three things:
  * that free number from earlier,
  * the number you would like to send to, and
  * a body message that you want to send through SMS.

# Creating a Twilio integration with Novu

Creating a Twilio integration with Novu is quite simple. Just follow these steps:

* Visit the [Integrations Store](https://web.novu.co/integrations) on Novu.
* Click the "Add a provider" button.
* Locate **Twilio** and click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.
* Go to your [Console](https://console.twilio.com/) on Twilio and access the Account Info section at the bottom of the page
* Enter your `Account SID`, `Auth Token` and `Twilio Phone Number`.
* Click on the **Save** button.
* You should now be able to send SMS notifications using **Twilio** in Novu.

## Sending an WhatsApp message with Twillio

To send a WhatsApps message with Twillio integration prefix the phone number of the subscriber with `whatsapp:` as shown below.

```ts theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
  {
    to: {
      subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
      phone: 'whatsapp:555-4242'
    },
  }
);
```

Read more about [sending a Message with the Twilio API for WhatsApp](https://www.twilio.com/docs/whatsapp/tutorial).


# Add a new provider
Source: https://v0.x-docs.novu.co/community/add-a-new-provider

Steps to add a new provider to Novu

Interested in expanding Novu's capabilities? By contributing to our growing ecosystem, you can enhance Novu's reach and impact.

## How to add a new provider?

Novu currently supports five channels `in_app`, `push`, `email`, `chat` and `sms`.

For `in_app` we support only our own provider, so new providers cannot be added to this channel. For the other four channels, we support the integration of external providers. This guide will help in adding new providers for any of these 4 channels.

In this guide, we are adding a new provider for the email channel, but all of the mentioned steps are similar for other channels as well.

## Description

Providers allow us to handle message delivery over multiple channels.

We have multiple providers for each channel (SMS, Email, Push and Chat). To get started with adding a new provider let's look at setting up our repository.

## Requirements

* Node.js version v20.8.1
* MongoDB
* Redis
* **(Optional)** pnpm - Needed if you want to install new packages
* **(Optional)** localstack (required only in S3 related modules)

Need help installing the requirements? [Read more here](/community/run-in-local-machine)

<Note> We have used pnpm package manager in this guide. You can use npm as well. </Note>

## Initialization

Fork the novu repository and clone it in your local machine.

```shell theme={null}
git clone https://github.com/<'YOUR_GITHUB_USER_NAME'>/novu.git
```

To set up the repository, run the initial setup command:

```shell theme={null}
pnpm run setup:project
```

At the root of the project build the `node` package to get started.

```shell theme={null}
cd packages/node && pnpm run build
```

## Generate provider

After the project is initialized, a new provider can be generated using the below command.

```shell theme={null}
pnpm run generate:provider
```

<Note> Use the above command at the root of the project. </Note>

Choose the provider type.

```shell theme={null}

? What type
❯ EMAIL
  SMS
  PUSH
  CHAT
```

Use `up` and `down` arrow to switch `channel` type and press `enter` to select.

For this example, we will be selecting `EMAIL` as our provider type. The name for our provider will be `example-provider`.

```
? Write the provider name`kebab-cased` (e.g. proton-mail, outlook365, yahoo-mail): example-provider
```

Make sure your selected name is not conflicting with our existing provider's name. Boilerplate files for this new `example-provider` is generated in your local machine project.

> In above example, we have given our provider name as example-provider for simplicity. If provider you want to add have name as twilio, don't use twilio-provider as name, instead use twilio only. If one provider supports multiple channels like infobip supports both sms and email channels, use infobip-email or infobip-sms to differentiate these providers.

Once our `example-provider` is generated we will need to begin working from within `packages/providers/src/lib/example-provider` directory. Make sure to write the test for this new provider.

```ts packages/providers/src/lib/example-provider/example-provider.provider.ts theme={null}
import {
  ChannelTypeEnum,
  ISendMessageSuccessResponse,
  IEmailOptions,
  IEmailProvider,
} from '@novu/stateless';

export class ExampleProviderEmailProvider implements IEmailProvider {
  id = 'example-provider'
  channelType = ChannelTypeEnum.EMAIL as ChannelTypeEnum.EMAIL;

  constructor(
    private config: {
      apiKey: string;
    }
  ) {}

  async sendMessage(options: IEmailOptions): Promise<ISendMessageSuccessResponse> {
    return {
      id: 'id_returned_by_provider',
      date: 'current_time'
  }
}
```

### Template test case for `example-provider`.

```ts packages/providers/src/lib/example-provider/example-provider.provider.sepc.ts theme={null}
import { ExampleProviderEmailProvider } from './example-provider.provider';

test('should trigger example-provider library correctly', async () => {});
```

<Info> Add the provider's SDK as a dependency in the provider's package.json file. Run `pnpm run setup:project` to build all dependencies again. Use this new sdk method to complete the provider's `sendMessage` function. Check the **[reference links for adding new providers](#reference-for-adding-new-providers)** section for each channel's provider example. </Info>

### Add provider logos

In order to present this new provider in the `integration store` we need logos in dark and light mode. Add dark color svg logo in  `apps/web/public/static/images/providers/dark/sqaure` directory and light color svg logo in  `apps/web/public/static/images/providers/light/sqaure` directory.

Use the provider name as the file name. The sample name for our above-added provider is `example-provider.svg`.

## Add config items to the list

In order to build the UI integration store, we need to provide it list of all provider integrations. This part is made up of two parts:

* Create credentials config
* Add ProviderId Enum
* Add provider configuration to the providers list

### 1. Create credentials config

Every provider requires some credentials to create an instance. Novu will add these credentials fields in the integration store provider's form so that users can use their credentials to connect to their preferred provider to use for that channel notification. For example, in the above added `example-provider`, we have only one credential `ApiKey`. We will need to add a config object for `example-provider` with all existing provider's configs like below.

```tsx libs/shared/src/consts/providers/credentials/provider-credentials.ts theme={null}
export const exampleProviderConfig: IConfigCredentials[] = [
  {
    key: CredentialsKeyEnum.ApiKey,
    displayName: "API Key",
    description: "This is API key for example provider",
    type: "text",
    required: true,
  },
  ...mailConfigBase,
];
```

1. Here the `key` is of type `CredentialsKeyEnum`.

> If a new key is added, add this key at these 3 places:-
>
> * In `CredentialsKeyEnum` at file `libs/shared/src/consts/providers/provider.enum.ts`
> * In `CredentialsDto` at file `apps/api/src/app/integrations/dtos/credentials.dto.ts`
> * In `credentials` field of `integrationSchema` at file `libs/dal/src/repositories/integration/integration.schema.ts`

2. `displayName` is a human-friendly easy to understand name which will be shown in the provider integration form for this credential.
3. `description` is a field that can be used to share more information about the credential.
4. `type` here means text field type. this can be a string for text, text for text-area, or a switch for the toggle.
5. `required` is of boolean type.
6. `mailConfigBase` is an object having default credentials required by any `email` provider. Make sure not to add duplicate providers which are already there in `mailConfigBase`. In the case of another channel provider, we will use that channel config base in place of `mailConfigBase`.

> A credential can be made secret by adding in ./secure-credentials.ts file.

### 2. Add ProviderId Enum

Add this new provider id in the respective channel provider id enum in file `libs/shared/src/consts/providers/provider.enum.ts`. As our `example-provider` is of email type, add this in `EmailProviderIdEnum` with all existing providers like below

```tsx libs/shared/src/consts/providers/provider.enum.ts theme={null}
export enum EmailProviderIdEnum {
  ExampleProvider = "example-provider",
}
```

### 3. Add provider to providers list

Now we need to add the provider data to the list located at `libs/shared/src/consts/providers/channels/email.ts`. Note that the `id` is the provider's name, `displayName` is the provider's name in Pascal's case, `credentials` are the ones we created in the previous step, `logoFileName` should be as it was on the adding logo step (with the format type included).

```tsx libs/shared/src/consts/providers/channels/email.ts theme={null}
{
  id: 'example-provider',
  displayName: 'Example Provider',
  channel: ChannelTypeEnum.EMAIL,
  credentials: exampleProviderConfig,
  // Use valid documentation link
  docReference: 'https://docs.example-provider.com/',
  logoFileName: { light: 'example-provider.svg', dark: 'example-provider.svg' }
}
```

## Add provider handler in the API

### 1. Adding the provider dependency in the application-generic package

In the previous step, we created a standalone provider package that will be published to NPM. However currently in our development environment, it is not yet published. In order to use it locally please go to the `package.json` located in `packages/application-generic/package.json` and add it manually to the dependencies list: `"@novu/<NEW_PROVIDER_NAME>": "^<VERSION>"`

> Please note that the provider name and version can be found from the provider package.json you created earlier.

After adding the dependency run `pnpm run setup:project` from the root of the mono repo. so, it can create the required symlinks for the newly created package.

### 2. Create a provider handler

In order to map internally the different providers’ credentials, we need to add a provider handler at the respective channel handlers located. For Email, it can be found at `apps/packages/application-generic/src/factories/mail/handlers`. Other channel handlers can also be found here.

Create a new file `example-provider.handler.ts` here with the following code

```tsx packages/application-generic/src/factories/mail/handlers/example-provider.handler.ts theme={null}
import { ChannelTypeEnum } from "@novu/shared";
import { ExampleProviderEmailProvider } from "@novu/example-provider";
import { BaseHandler } from "./base.handler";

export class ExampleProviderHandler extends BaseHandler {
  constructor() {
    super("example-provider", ChannelTypeEnum.EMAIL);
  }

  buildProvider(credentials, from: string) {
    const config: { apiKey: string } = { apiKey: credentials.apiKey };

    this.provider = new ExampleProviderEmailProvider(config);
  }
}
```

Add this line given below to export this handler

```tsx packages/application-generic/src/factories/mail/handlers/index.ts theme={null}
export * from "./example-provider.handler";
```

### 3. Add handler to factory

The last step is to initialize the handler in the factory located in `packages/application-generic/src/factories/mail/mail.factory.ts`

```tsx packages/application-generic/src/factories/mail/mail.factory.ts theme={null}
import { ExampleProviderHandler } from "./handlers";

export class MailFactory {
  handlers: IMailHandler[] = [new ExampleProviderHandler()];
}
```

### Final Steps

Now, build the project again using this command

```shell theme={null}
pnpm run setup:project
```

Run novu in your local machine. Read [here](/community/run-in-local-machine) to learn on how to run novu on a local machine and test this new provider.

Run the below command in the root of the project to run the providers test

```shell theme={null}
pnpm run test:providers
```

If everything is working fine without any error, commit your local branch changes, push this branch and create a new pull request to our main repo.

Hurray 🎉! You have successfully added a new provider in Novu!

<Info>️ In this guide, we have used only one credential `apiKey` for our `example-provider`. This is for reference purposes only. A provider can have more than one credential as per its `SDK` requirements. At each step, you will need to add all credentials carefully. Check providers referenced below for more information. </Info>

### Reference for Adding New Providers

* [SendGrid Email Provider](https://github.com/novuhq/novu/blob/next/providers/sendgrid/src/lib/sendgrid.provider.ts)
* [Twilio SMS Provider](https://github.com/novuhq/novu/blob/next/providers/twilio/src/lib/twilio.provider.ts)
* [FCM Push Provider](https://github.com/novuhq/novu/blob/next/providers/fcm/src/lib/fcm.provider.ts)
* [Slack Chat Provider](https://github.com/novuhq/novu/blob/next/providers/slack/src/lib/slack.provider.ts)
* [Resend - How to add an Email Provider to Novu](https://dev.to/novu/resend-how-to-add-an-email-api-provider-to-novu-49cd)


# Changelog
Source: https://v0.x-docs.novu.co/community/changelog

See the most recent changes and learn about how to shape Novu's future

<Card title="Novu's Changelog" icon="map" href="https://github.com/novuhq/novu/releases/">
  Learn about what's changed, new features, bug fixes, and see Novu's history across versions.
</Card>

Using the changelog, you can:

* Keep an eye on the latest updates,
* Learn more about the newly added features and improvements, and
* Stay informed about bug fixes and enhancement

## Getting involved:

Community is at the heart of everything we do at Novu. To get more involved with the community, you can:

* **Fork and Contribute** to our open issues as well as suggest new ideas at our [github repository](https://github.com/novuhq/novu)
* **Join our community** to ask questions, engage with other users and share ideas. Here's the [joining link.](https://discord.gg/novu?ref=docs-join-our-community)
* **Participate in our office hours** to learn more and connect with our core team. Join us [here.](https://www.youtube.com/@novuhq/streams)

<Tip>
  Remember, we're not building just another product, but a community of passionate developers who shape its evolution. Our changelog isn't just a list of updates but a reflection of our journey together. Your voice matters, and your ideas and feedback are what fuel our progress and shape our future. So, join us in this adventure, and – Let's build something amazing, one feature at a time!
</Tip>


# Novu Community Code of conduct
Source: https://v0.x-docs.novu.co/community/code-of-conduct

The set of rules and guidelines that govern interaction among community members

As a community-driven company, Novu is committed to creating an inclusive and welcoming environment for all members, regardless of factors such as age, body size, disability, ethnicity, gender identity, experience level, education, socio-economic status, nationality, personal appearance, race, religion, or sexual orientation.

However, diverse communities may face challenges, such as potential misunderstandings and miscommunications. To ensure respectful interactions, free from behaviour that may create an unsafe environment, we have established this Code of Conduct.

These guidelines do not cover every possible scenario comprehensively but serve as a guiding light towards courteous interactions among community members, aligning with the overarching principle of avoiding unprofessional behaviour. This Code of Conduct applies to all events and participants, aiming to maintain a welcoming and healthy environment for our community.

Traits of a Novu community member include:

### Being considerate and using appropriate channels

Contributions of every kind have far-ranging consequences. Just as your work depends on the work of others, decisions you make surrounding your contributions to the Novu community will affect your fellow community members. Use appropriate channels for what you’re about to say and refrain from tagging a role that sends out a lot of pings. You are strongly encouraged to take those consequences into account while making decisions.

### Adhering to these standards

It's crucial to keep in mind that our community members are from all kinds of backgrounds, so the members are expected to:

* Demonstrate empathy and kindness toward other people
* Be respectful of differing opinions, viewpoints, and experiences
* Give and accept constructive feedback gracefully
* Accept responsibility and apologise to those affected by mistakes, and learn from such experiences
* Focus on what is best not just for us as individuals, but for the overall community!

### Patience

Our community thrives on the generosity of volunteered time. Questions, contributions, and support requests may embark on a time-travelling journey before finding their destination. Repeated "bumps" or persistent "reminders" don’t display patience and are looked down upon. Lastly, it is a bad practice to ask general questions to a specific person (in direct messages for example). Try to ask in public as much as you can, and patiently wait for the response

### Inclusivity, kindness and respectfulness

Please be courteous and respectful to fellow members. Avoid offensive comments related to age, body size, disability, ethnicity, gender identity, experience level, education, socio-economic status, nationality, personal appearance, race, religion, or sexual orientation.

Strictly prohibited are sexualized imagery, violence, intimidation, stalking, disruptions, sharing personal information without explicit permission, unwanted physical contact, and unwelcome sexual attention.

Use inclusive language respecting our community's diversity.

Avoid assumptions about others' backgrounds. Maintain a positive and professional demeanour, refraining from threatening or inappropriate behaviour.

**We have zero tolerance for discrimination**. Any form of discrimination, including harassment, will lead to immediate consequences, potentially expulsion.

### Inquisitive

***The only stupid question is the one that does not get asked***.

We encourage our users to ask early and ask often. Rather than asking whether you can ask a question (the answer is always yes!), instead, simply ask your question. You are encouraged to provide as many specifics as possible.

Code snippets in the form of images are bad practice. Instead, use text formatted as code (using backticks) on Discord or simply send a gist. Refrain from pasting multiple lines of code directly into the chat channels - instead use [gist.github.com](http://gist.github.com/) or another paste site to provide code snippets.

### Helpful

Novu welcomes users of all skill levels. We were all beginners once, and a supportive environment is essential for the community to thrive. While it can be repetitive to answer the same questions, members are expected to be courteous and helpful to everyone.

Avoid sarcastic responses and prioritize useful information. Everyone should read the provided documentation. We're here to answer questions, offer guidance, and suggest workflows, but not to do your job for you.

### Anti-harassment policy

Harassment includes (but is not limited to) all of the following behaviors:

* Offensive comments related to gender (including gender expression and identity), age, sexual orientation, disability, physical appearance, body size, race, and religion.
* Derogatory terminology including words commonly known to be slurs
* Posting sexualized images or imagery in public spaces
* Deliberate intimidation
* Stalking
* Posting others’ personal information without explicit permission
* Sustained disruption of talks or other events
* Inappropriate physical contact
* Unwelcome sexual attention

Immediate compliance is expected from participants asked to cease harassing behaviour. Sponsors must adhere to the anti-harassment policy, refraining from using sexualized images or creating a sexualized environment at events. Volunteer organizers, including meetup staff, should also avoid sexualized attire.

Continuing inappropriate behaviour after being asked to stop constitutes harassment, even if not explicitly mentioned in this policy. It is respectful to stop doing something when asked to do so, and all community members are expected to promptly comply with such requests.

### Reporting policy violations

Instances of abusive, harassing, or otherwise unacceptable behaviour may be reported to anyone with administrative power in the community (Admins or Moderators on Discord, members of the ‘DevRel’ role), or to the local organizers of an event or to [support@novu.co](mailto:support@novu.co). Meetup organizers are encouraged to prominently display points of contact for reporting unacceptable behaviour at local events.

If a participant engages in harassing behaviour, the meetup organizers may take any action they deem appropriate. These actions may include but are not limited to warning the offender, expelling the offender from the event, and barring the offender from future community events.

Organizers will be happy to help participants contact security or local law enforcement, provide escorts to an alternate location, or otherwise assist those experiencing harassment to feel safe during the meetup. We value the safety and well-being of our community members and want everyone to feel welcome at our events, both online and offline.

We expect all participants, organizers, speakers, and attendees to follow these policies at all of our event venues and event-related social events.

### Enforcement Guidelines

Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:

1. **Correction**

* `Community Impact`: Use of inappropriate language or other behaviour deemed unprofessional or unwelcome in the community.
* `Consequence`: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behaviour was inappropriate. A public apology may be requested.

2. **Warning**

* `Community Impact`: A violation through a single incident or series of actions.
* `Consequence`: A warning with consequences for continued behaviour. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.

3. **Temporary Ban**

* `Community Impact`: A serious violation of community standards, including sustained inappropriate behaviour.
* `Consequence`: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.

4. **Permanent Ban**

* `Community Impact`: Demonstrating a pattern of violation of community standards, including sustained inappropriate behaviour, harassment of an individual, or aggression toward or disparagement of classes of individuals.
* `Consequence`: A permanent ban from any sort of public interaction within the community.

The Novu Community Code of Conduct is licensed under the Creative Commons Attribution-Share Alike 3.0 license.

Our Code of Conduct was adapted from Codes of Conduct of other open-source projects, including:

* **Contributor Covenant**
* **Elastic**
* **The Fedora Project**
* **OpenStack**
* **Ansible**
* **Puppet Labs**
* **Ubuntu**

Community Impact Guidelines were inspired by Mozilla's code of conduct enforcement ladder.

For answers to common questions about this code of conduct, see the FAQ at [https://www.contributor-covenant.org/faq](https://www.contributor-covenant.org/faq).

Translations are available at [https://www.contributor-covenant.org/translations](https://www.contributor-covenant.org/translations).


# Feature Flags
Source: https://v0.x-docs.novu.co/community/feature-flags

Learn how to enable/disable specific features in Novu

Feature flags allow to turn certain functionality on and off based on configuration. In this way, users can preview beta features in their deployments.

To enable the specific feature, you need to pass an environment variable to all services:

<Note>
  Feature flag environment variable accepts boolean values: `true` or `false`.
</Note>

* `IS_MULTI_PROVIDER_CONFIGURATION_ENABLED` adds ability to connect multiple providers per channel and make them active. It also shows redesigned integrations store page.

<Frame>
  <img />
</Frame>

* `IS_MULTI_TENANCY_ENABLED` adds ability to manage tenants from dashboard.

<Frame>
  <img />
</Frame>

* `IS_TEMPLATE_STORE_ENABLED` enables template store which contains pre-made workflows for common use cases (like **Password Reset** workflow etc).

<Frame>
  <img />
</Frame>


# Get involved with the Novu Community
Source: https://v0.x-docs.novu.co/community/get-involved

Your guide for engaging with the Novu Community

## Our Community

At Novu, we're a vibrant, open-source community driven by passion, collaboration, and a shared love for pushing boundaries. We believe in the power of community-driven development, where every voice matters and every contribution counts. As such, contributions are at the heart of how we evolve and progress forward.

## Join the conversation

* Read our [code of conduct](/community/code-of-conduct)
* Say “Hi!” in our [Discord Server](https://discord.gg/novu?ref=docs-community-introduction)
* Explore our [open issues](https://github.com/novuhq/novu/issues)
* Subscribe to our newsletter [to stay in the know](https://novu.co/novu-community-2-0/?utm_campaign=docs-comm2-get-involved)

## Getting help

Our fellow community members are always ready to help you get past a blocker. However, you can take a few things into consideration to help them help you:

* Share as many details as you can share. It will help us in debugging the issue.
* If there is any bug, please share steps to reproduce that bug.
* If there is any issue in running Novu on a local machine, please share system details like operating system, RAM size, npm version and node version.
* If there is any issue in our backend SDKs, please mention the SDK version and relevant details.
* If looking for self-hosting support, please share `Novu Version` and remote server details. Our latest version is `0.24.0`. Please be patient with self-hosting help. We are a small team and we will try our best to help you.

<Tip>Intercome is suitable if you're using Novu cloud or. Kindly use Discord or Github for community self-hosting questions.</Tip>

## Contributing

All community members are of one of the following four types:

1. Open source users
2. Active member
3. Power member
4. Novu Ambassador

### Become an active community member

* Everyone who joins our community becomes an open-source user automatically.
* You can become an active community member by:
  * Submitting >2 PRs
  * Opening >2 issues
  * Sending >5 messages on Github
  * Commenting >3 times on Github
* Active community members are one step closer to becoming Power community members and then an active moderator.

### Become a power community member

* All active community members are eligible to become a power community member and can become so by having at least one of the following:
  * Submitting 3 PRs
  * Opening 3 Issues
  * Sending 10 Discord messages
  * Commenting >10 times on Github
* Power community members are just one step away from becoming a Novu ambassador.

### Become a Novu Ambassador

A Novu ambassador is a trusted power member of the community that can do the following:

* Love exploring and sharing their knowledge of any technology with other developers.
* Often write and speak about Novu.
* Possess strong Novu expertise and often help and support Novu users within the community.
* Socially influence developers with some knowledge of Novu.
* Consistently contribute to Novu OSS product.

We are launching the Novu Ambassador program soon with amazing perks. Stay tuned!

## Activities

Are you passionate about notifications like we are? There are many different—and easy—ways to get involved.

### Help in onboarding and answering questions.

* Welcome new users into the community
* Answer questions in the [community support channel](https://discord.com/channels/895029566685462578/1019663407915483176).
* Offer input and opinions about various solutions you have tried.

### Improve our documentation

* Check out our[GitHub repo](https://github.com/novuhq/docs)
* No documentation is perfect, and neither is ours
* Help us improve our docs by
  * Updating outdated examples
  * Correcting typos and language for clarity
  * Find and fix broken links, etc.

### Help with the SDKs

* Link to contributors guide([https://github.com/novuhq/novu/blob/next/CONTRIBUTING.md](https://github.com/novuhq/novu/blob/next/CONTRIBUTING.md))
* We have SDKs in various languages and frameworks, most written and maintained by community members.
* You can either become a maintainer there or help the existing maintainers by bringing the SDK up to speed with the latest features present in the core product.
  * We have backend SDKs in the following: [Node.js](https://github.com/novuhq/novu/tree/next/packages/node), [PHP](https://github.com/novuhq/novu-php), [.NET](https://github.com/novuhq/novu-dotnet), [Elixir](https://github.com/novuhq/novu-elixir), [Go](https://github.com/novuhq/go-novu), [Ruby](https://github.com/novuhq/novu-ruby), [Python](https://github.com/novuhq/novu-python) [Laravel](https://github.com/novuhq/novu-laravel), and [Kotlin](https://github.com/novuhq/novu-kotlin)
  * And client-side SDKs in the follwing: [Vue](https://github.com/novuhq/novu/tree/next/packages/notification-center-vue), [React](https://github.com/novuhq/novu/tree/next/packages/notification-center), [Angular](https://github.com/novuhq/novu/tree/next/packages/notification-center-angular), [Web Component](https://github.com/novuhq/novu/tree/next/packages/notification-center), [iframe embed](https://docs.novu.co/notification-center/client/iframe), and [Headless Javascript.](https://docs.novu.co/notification-center/client/headless/get-started)

### Create content

* Content writers program: Apply to become a content writer with us and get paid to write about use-cases highlighting how you solved a problem using Novu
* Write an article about what you built with Novu and share it with the community. We’ll give you a shout out!

### PRs, issues, and bug reports

* Check out our [contributors guide](https://github.com/novuhq/novu/blob/next/CONTRIBUTING.md)
* Once you’ve gone through our [development process](https://docs.novu.co/community/run-in-local-machine), you can contribute directly to open issues.
* Open a new issue if a relevant one isn’t already open.
* Also, you can create bug reports if you find a bug somewhere.
* Or a feature request if you find something that should be a feature but isn't.

<Info>
  At Novu, we believe that no contribution is small, and the only wrong question is the one that doesn’t get asked. So feel free to ask any question or raise that Pull Request. You’re always welcome here! 🤗
</Info>

### Participate in office hours

* We have frequent (replace with interval— twice weekly, weekly, etc.) and topic-specific office hours that offer the ability to engage in real-time with Novu staff and other community members
* In these sessions, offer input, opinions, examples, etc. to contribute!

We’re excited to have you on board and look forward to your valuable contributions!

Together, we’ll shape the future of Novu. 🫂


# MacOS/Linux
Source: https://v0.x-docs.novu.co/community/machine-setup

Learn how to configure your local machine to run Novu

## Terminal upgrade (Optional)

### Install ZSH

ZSH is a shell on steroids, it has multiple plugins and functionality that can save a lot of time.

To install zsh run in your command line:

```shell theme={null}
sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
```

<Note>
  If you previously haven’t installed git on the machine, a prompt to install
  git will show up. After installation, run the `sh` command from above again.
</Note>

<Note>
  Make sure you have a `~/.zshrc` exists, if not it might be an indicator that
  the installation failed for some reason.
</Note>

### ZSH auto-complete plugin

Add the autocomplete plugin for autocompleting previously typed commands in the shell. Follow the instructions [here](https://github.com/zsh-users/zsh-autosuggestions/blob/master/INSTALL.md#oh-my-zsh).

### Powerlevel10k (optional)

[Powerlevel10k](https://github.com/romkatv/powerlevel10k) is a theme for Zsh. It emphasizes [speed](https://github.com/romkatv/powerlevel10k#uncompromising-performance), [flexibility](https://github.com/romkatv/powerlevel10k#extremely-customizable), and [out-of-the-box experience](https://github.com/romkatv/powerlevel10k#configuration-wizard).

1. Clone the repository:

   `git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k`

2. Set `ZSH_THEME="powerlevel10k/powerlevel10k"` in `~/.zshrc`.

3. Restart your terminal and follow the onboarding wizard to configure it to your likings and preferences.

## Command Line Tools, Homebrew & Casks

Every developer utilizes *Command Line Tools*. A simple terminal command will allow you to download these. It will ask you to confirm after you have entered the command.

```shell theme={null}
xcode-select --install
```

### Homebrew & Casks

[Homebrew](https://brew.sh/), it’s the missing package manager for macOS, and quite powerful at that.

Copy and paste the following code into your terminal to install Homebrew.

```shell theme={null}
/bin/shell -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

It will ask you to enter 'Return' to confirm the installation.

<Note>
  After installation run, the `echo` and `eval` commands shown on screen to add
  brew to your shell executables
</Note>

## Setting up git

To set up git and create an access token for GitHub, suggested installing [GitHub Desktop](https://www.notion.so/Dev-Machine-Setup-98d274c80fa249b0b0be75b9a7a72acb?pvs=21) before.

## Helpful settings

Show hidden files in Finder: `cmd + shift + .` or in the terminal:

```shell theme={null}
defaults write com.apple.finder AppleShowAllFiles YES
```

## Development Environment

### Node & NVM

For installing node we suggest installing it using [NVM](https://github.com/nvm-sh/nvm) (Node Version Manager) for easily managing multiple node versions.

1. Install nvm on your machine.

```shell theme={null}
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | shell
```

<Note>
  Make sure that you have installed zsh previously, so NVM can automatically
  inject the executable to PATH in the .zshrc config file.
</Note>

2. After installing nvm and checking that it’s in the path by running `nvm --version` in your CLI. You can now install our node version:

<Note>
  After running the install script, if you get `nvm: command not found` or see
  no feedback from your terminal after you type `command -v nvm`, simply **close
  your current terminal, open a new terminal**, and try verifying again.
</Note>

3. Optional for M1 processors - Install Rosetta.

Rosetta enables a Mac with Apple silicon to use apps built for a Mac with an Intel processor.

```shell theme={null}
softwareupdate --install-rosetta
```

### PNPM

For package management, we use [PNPM](https://pnpm.io/) instead of npm or yarn to speed up our install times and space efficiency. To install pnpm globally run:

```shell theme={null}
npm install -g pnpm@8.9.0
```

### Docker

Follow the installation guide on [docker website](https://docs.docker.com/desktop/mac/install/) to install docker on your own machine. For ease of use, we suggest installing **Docker Desktop**.

### AWS CLI

Follow the instructions to install the AWS CLI so you can use it to create env later on, based on existing S3 buckets:

[Installing or updating the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

You should get something like this:

<Frame>
  <img alt="AWS CLI" />
</Frame>

If needed, see:

[Resolve "Unable to locate credentials" error in Amazon S3](https://aws.amazon.com/premiumsupport/knowledge-center/s3-locate-credentials-error/)

### Run LocalStack

This is needed only when you upload files (for example - an image) in the admin panel from your local environment.

LocalStack emulates cloud service that runs in a single container on your computer. So you can run your AWS applications on your local machine without connecting to the remote cloud provider.

1. Build a container and run it:

```shell theme={null}
docker run --rm -it -p 4566:4566 -p 4571:4571 localstack/localstack
```

2. Create local S3 buckets needed for the app:

   In **local** environment:

   ```shell theme={null}
   aws --endpoint-url=http://localhost:4566 s3 mb s3://novu-local
   ```

   In **test** environment:

   ```shell theme={null}
   aws --endpoint-url=http://localhost:4566 s3 mb s3://novu-test
   ```

3. Update cors:

   ```json theme={null}
   aws --endpoint-url=http://localhost:4566 s3api put-bucket-cors --bucket novu-local --cors-configuration file://cors.json
   ```

   ```json cors.json theme={null}
   {
     "CORSRules": [
       {
         "AllowedOrigins": ["*"],
         "AllowedHeaders": ["*"],
         "AllowedMethods": ["GET", "PUT", "POST", "DELETE"],
         "MaxAgeSeconds": 3000,
         "ExposeHeaders": ["x-amz-server-side-encryption"]
       }
     ]
   }
   ```

### MongoDB

After installing brew you can easily install the MongoDB community edition.

1. Tap the [MongoDB Homebrew Tap](https://github.com/mongodb/homebrew-brew) to download the official Homebrew formula for MongoDB and the Database Tools, by running the following command in your macOS Terminal:

```shell theme={null}
brew tap mongodb/brew
```

2. To install MongoDB, run the following command in your macOS Terminal application

   1. You might need to update the Command Line Tools to be compatible with Xcode - see

   [Sign in with your Apple ID](https://developer.apple.com/download/all/?q=Xcode)

```shell theme={null}
brew install mongodb-community@5.0
```

3. Run the service in the background and start automatically after restart.

```shell theme={null}
brew services start mongodb/brew/mongodb-community@5.0
```

### Redis

After installing homebrew run the redis installation

```shell theme={null}
brew install redis
```

After installation run the service to start on system start as well.

```shell theme={null}
brew services restart redis
```

### Local dev domain (Optional)

This will allow you to use [local.novu.co](http://local.novu.co) instead of [localhost](http://localhost) when accessing the service on your machine.

Open the `/etc/hosts` file:

```shell theme={null}
sudo nano /etc/hosts
```

And add the [local.novu.co](http://local.novu.co) domain

```shell theme={null}
127.0.0.1       local.novu.co
```

### Code Editor

Feel free to install your favorite code editor. We supply licenses for [WebStorm](https://www.notion.so/WebStorm-7570ab1037bf494d88d0f9b544ae3b79?pvs=21), or you can [Visual Studio Code](https://code.visualstudio.com/download) if you prefer it.

### Productivity tools

* GitHub Desktop (Optional)

GitHub Desktop simplifies the development workflow and interaction with Git. [Download](https://desktop.github.com/) the client from their website.

* Clean your Dock bar (Optional)

For better productivity and wellness, we suggest removing the not-used apps from LaunchBar. Don’t worry if you will remove most apps from there. You can always use the spotlight to open the apps you need. Clean workspace === Happy life :)
Right Click on the app icon > Options > Remove from Dock

<Frame>
  <img alt="Dock" />
</Frame>


# Monorepo Structure
Source: https://v0.x-docs.novu.co/community/monorepo-structure

Learn the components of Novu's monorepo

In this guide, we will explore the Novu mono-repo structure and high-level structure of the different libraries and services we use.

## Setting up the monorepo

Novu uses [PNPM](https://pnpm.js.org/) as its package manager, and [NX](https://nx.dev/) as its build CLI tool. PNPM reduces the installation time and generates symlinks for all the internal packages we use.

To initialize the monorepo, run the following command from the root of the project:

```bash theme={null}
npm run setup:project
```

This will:

* run `pnpm install`, which will download all the needed dependencies and create symlinks for packages.
* copy the `.env.example` file to the `.env` file for the API service.
* execute the `npm run build` command to build all the dependency trees locally.

For additional information on running Novu locally, visit the [run locally](https://docs.novu.co/community/run-in-local-machine) guide.

## Apps

The `apps` folder contains high-level applications and APIs. The app's outputs usually contain deployable units that a user can interact with either as an API or as a web/cli application.

<Steps>
  <Step title="API">
    The API package is our main service for handling backend logic. It handles anything from authentication, authorization, workflow management, triggering events, etc... This is where the Novu business logic is handled.
  </Step>

  <Step title="WS aka Web Socket">
    This is the WebSocket NestJs server which connects to the widget and provides real-time updates about new notifications to the widget consumer.
  </Step>

  <Step title="Web aka Admin Panel">
    This is the Novu admin panel which is used to visually communicate with the API. You can configure workflows, manage content, enable or disable notifications, visually track the notification activity feed, etc...

    The `WEB` project is a create-react-app built, well, with React. 😄
  </Step>

  <Step title="Widget">
    This is the client of our embeddable notification center widget. It is consumed mainly with the embed script in an Iframe. We can access it on port 4500 to interact with it directly.
  </Step>

  <Step title="Worker">
    This is our service for managing and handling workers.
  </Step>
</Steps>

## Libs

<Steps>
  <Step title="@novu/dal">
    The `DAL` is our Data-Access-Layer. This is our connection to the DB service and wraps MongoDB and mongoose. When another service or API needs to consume the DB, it does not do that directly but uses the DAL as an interface. Importing `mongoose` directly outside the `dal` is not allowed.
  </Step>

  <Step title="@novu/testing">
    This is a utility library that contains testing helpers. The testing helpers can generate test sessions and other functionality for e2e and unit-tests between our services.
  </Step>

  <Step title="@novu/shared">
    The shared library contains reusable code and typescript interfaces between client and server packages. Code in the shared library should not contain any sensitive content because it can be accessed and downloaded by the web or other clients.
  </Step>

  <Step title="@novu/embed">
    This is the connector between our client's web app and the widget project. It’s a small shim script that generates an iframe and attaches it to a client-specified div to host the notification widget.

    If you are familiar with the Google Analytics embedded snippet or intercom-like embeddings, it uses the same mechanics.
  </Step>
</Steps>

## Packages (on npm)

<Steps>
  <Step title="@novu/node">
    A Standalone Node.js wrapper around the Novu API. Exists to provide type-safe and easier access to the different API endpoints Novu exposes (Triggers, subscribers, etc…).
  </Step>

  <Step title="@novu/nest">
    A Nest.js wrapper around the `@novu/node` package was created by the community to easily interact with the core library from a nest project. Also released on NPM as a package.
  </Step>

  <Step title="@novu/notification-center">
    React component library that contains widget bell with the notification center. Can get override of components like ‘bell icon’, and ‘notification center’.
  </Step>
</Steps>

## Providers

These are the API wrappers created by the community to wrap communication providers in the following channels:

Novu provides a single API to manage providers across multiple channels with a simple-to-use interface.

### 💌 Email

* [Sendgrid](https://github.com/novuhq/novu/tree/main/providers/sendgrid)
* [Netcore](https://github.com/novuhq/novu/tree/main/providers/netcore)
* [Mailgun](https://github.com/novuhq/novu/tree/main/providers/mailgun)
* [SES](https://github.com/novuhq/novu/tree/main/providers/ses)
* [Postmark](https://github.com/novuhq/novu/tree/main/providers/postmark)
* [Custom SMTP](https://github.com/novuhq/novu/tree/main/providers/nodemailer)
* [Mailjet](https://github.com/novuhq/novu/tree/main/providers/mailjet)
* [Mandrill](https://github.com/novuhq/novu/tree/main/providers/mandrill)
* [SendinBlue](https://github.com/novuhq/novu/tree/main/providers/sendinblue)

### 📞 SMS

* [Twilio](https://github.com/novuhq/novu/tree/main/providers/twilio)
* [Plivo](https://github.com/novuhq/novu/tree/main/providers/plivo)
* [SNS](https://github.com/novuhq/novu/tree/main/providers/sns)
* [Nexmo - Vonage](https://github.com/novuhq/novu/tree/main/providers/nexmo)
* [Sms77](https://github.com/novuhq/novu/tree/main/providers/sms77)
* [Telnyx](https://github.com/novuhq/novu/tree/main/providers/telnyx)
* [Termii](https://github.com/novuhq/novu/tree/main/providers/termii)
* [Gupshup](https://github.com/novuhq/novu/tree/main/providers/gupshup)

### 📱 Push

* [FCM](https://github.com/novuhq/novu/tree/main/providers/fcm)
* [Expo](https://github.com/novuhq/novu/tree/main/providers/expo)
* [SNS](https://github.com/novuhq/novu/tree/main/providers/sns)

### 👇 Chat

* [Slack](https://github.com/novuhq/novu/tree/main/providers/slack)
* [Discord](https://github.com/novuhq/novu/tree/main/providers/discord)

### 📱 In-App

* [Novu](https://docs.novu.co/notification-center/getting-started)


# Roadmap
Source: https://v0.x-docs.novu.co/community/roadmap

Learn about our roadmap

<Card title="Novu's Roadmap" icon="map" href="https://roadmap.novu.co/roadmap">
  Learn about ongoing developments, upcoming plans, and items in our backlog..
</Card>

Your involvement in shaping the future of our notification infrastructure solution is highly encouraged.

## Get involved

**Submit Ideas:** If you have a new feature idea or an enhancement suggestion, don't hesitate to submit it through our [roadmap page](https://roadmap.novu.co/roadmap). Your creativity fuels our innovation!

**Upvote and Comment:** Review the existing feature requests and upvote the ones that resonate with you. Feel free to provide additional insights or use-cases through comments.

**Contribute:** If you're a developer, you can actively contribute to the development of the features in progress or even the backlog ones. [Join our community of contributors](https://discord.gg/novu?ref=docs-contribute) and help us bring these enhancements to life.

<Tip>Remember, this roadmap is a living document that evolves based on your input and the direction the community decides to take. Your voice matters, and we're excited to work together in building a robust notification infrastructure solution that meets everyone's needs.</Tip>


# Run Novu in local machine
Source: https://v0.x-docs.novu.co/community/run-in-local-machine

Prerequisites and steps to run Novu in local machine. Learn how to set up Novu on your local environment for testing and development.

[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/novuhq/novu)

### Requirements

* Node.js version v20.8.1
* MongoDB
* Redis
* **(Optional)** pnpm - Needed if you want to install new packages
* **(Optional)** localstack (required only in S3 related modules)

Need help installing the requirements? Read more [here](/community/machine-setup).

<Note>We recommend having at least 8GB of RAM to run Novu on a local machine as Novu has multiple services running together with external services like redis, mongodb etc.</Note>

<iframe />

### Setup the project

After installing the required services on your machine, you can clone and set up
your forked version of the project:

1. Clone the repository

<Tabs>
  <Tab title="Novu Org">
    ```shell theme={null}
    git clone https://github.com/novuhq/novu.git
    ```
  </Tab>

  <Tab title="Forked Repo">
    ```shell theme={null}
    git clone https://github.com/{YOUR_GITHUB_USER_NAME}/novu.git
    ```
  </Tab>
</Tabs>

2. Install all dependencies

```shell theme={null}
cd novu && npm run setup:project
```

3. Run the project

```shell theme={null}
npm run start
```

The `npm run start` will start the Jarvis CLI tool which allows you to run the whole project with ease. If you only want to run parts of the platform, you can use the following run commands from the root project:

* **start:dev** - Synonym to `npm run start`
* **start:web** - Only starts the web management platform
* **start:ws** - Only starts the WebSocket service for notification center updates
* **start:widget** - Starts the widget wrapper project that hosts the notification center inside an iframe
* **start:api** - Runs the API in watch mode
* **start:worker** - Runs the worker application in watch mode
* **start:dal** - Runs the Data Access Layer package in watch mode
* **start:shared** - Starts the watch mode for the shared client and API library
* **start:node** - Runs the `@novu/node` package in watch mode
* **start:notification-center** - Runs and builds the React package for the Novu notification center

<iframe />

<iframe />

### Set up your environment variables

If you have used Jarvis CLI tool from the previous step you don't need to setup the env variables as Jarvis will do that on the first run if setup wasn't done before.

The command `npm run setup:project` creates default environment variables that are required to run Novu in a development environment. However, if you want to test certain parts of Novu or run it in production mode, you need to change some of them. These are all the available environment variables:

<AccordionGroup>
  <Accordion title="API Backend">
    * `NODE_ENV` (default: local)The environment of the app. Possible values are: dev, test, production, ci, local
    * `S3_LOCAL_STACK`The AWS endpoint for the S3 Bucket required for storing various media
    * `S3_BUCKET_NAME`The name of the S3 Bucket
    * `S3_REGION`The AWS region of the S3 Bucket
    * `PORT`The port on which the API backend should listen on
    * `FRONT_BASE_URL`The base url on which your frontend is accessible for the user. (e.g. web.novu.co)
    * `DISABLE_USER_REGISTRATION` (default: false)If users should not be able to create new accounts. Possible values are: true, false
    * `REDIS_HOST`The domain / IP of your redis instance
    * `REDIS_PORT`The port of your redis instance
    * `REDIS_PASSWORD`Optional password of your redis instance
    * `REDIS_DB_INDEX`The Redis database index
    * `REDIS_CACHE_SERVICE_HOST`The domain / IP of your redis instance for caching
    * `REDIS_CACHE_SERVICE_PORT`The port of your redis instance for caching
    * `REDIS_CACHE_DB_INDEX`The Redis cache database index
    * `REDIS_CACHE_TTL`The Redis cache ttl
    * `REDIS_CACHE_PASSWORD`The Redis cache password
    * `REDIS_CACHE_CONNECTION_TIMEOUT`The Redis cache connection timeout
    * `REDIS_CACHE_KEEP_ALIVE`The Redis cache TCP keep alive on the socket timeout
    * `REDIS_CACHE_FAMILY`The Redis cache IP stack version
    * `REDIS_CACHE_KEY_PREFIX`The Redis cache prefix prepend to all keys
    * `REDIS_CACHE_SERVICE_TLS`The Redis cache TLS connection support
    * `IN_MEMORY_CLUSTER_MODE_ENABLED`The flag that enables the cluster mode. It might be Redis or ElastiCache cluster, depending on the env variables set for either service.
    * `ELASTICACHE_CLUSTER_SERVICE_HOST`ElastiCache cluster host
    * `ELASTICACHE_CLUSTER_SERVICE_PORT`ElastiCache cluster port
    * `REDIS_CLUSTER_SERVICE_HOST`Redis cluster host
    * `REDIS_CLUSTER_SERVICE_PORTS`Redis cluster ports
    * `REDIS_CLUSTER_DB_INDEX`Redis cluster database index
    * `REDIS_CLUSTER_TTL`Redis cluster ttl
    * `REDIS_CLUSTER_PASSWORD`Redis cluster password
    * `REDIS_CLUSTER_CONNECTION_TIMEOUT`Redis cluster connection timeout
    * `REDIS_CLUSTER_KEEP_ALIVE`Redis cluster TCP keep alive on the socket timeout
    * `REDIS_CLUSTER_FAMILY`Redis cluster IP stack version
    * `REDIS_CLUSTER_KEY_PREFIX`Redis cluster prefix prepend to all keys
    * `JWT_SECRET`The secret keybase which is used to encrypt / verify the tokens issued for authentication
    * `SENDGRID_API_KEY`The api key of the Sendgrid account used to send various emails
    * `MONGO_URL`The URL of your MongoDB instance
    * `MONGO_MAX_POOL_SIZE`The max pool size of the MongoDB connection
    * `NOVU_API_KEY`The api key of web.novu.co used to send various emails
    * `SENTRY_DSN`The DSN of sentry.io used to report errors happening in production
  </Accordion>

  <Accordion title="Worker">
    * `NODE_ENV` (default: local)The environment of the app. Possible values are: dev, test, production, ci, local
    * `PORT`The port on which the Worker app should listen on
    * `STORE_ENCRYPTION_KEY`The encryption key used to encrypt/decrypt provider credentials
    * `MAX_NOVU_INTEGRATION_MAIL_REQUESTS`The number of free emails that can be sent with the Novu email provider
    * `NOVU_EMAIL_INTEGRATION_API_KEY`The Novu email provider Sentry API key
    * `STORAGE_SERVICE`The storage service name: AWS, GCS, or AZURE
    * `S3_LOCAL_STACK`The LocalStack service URL
    * `S3_BUCKET_NAME`The name of the S3 Bucket
    * `S3_REGION`The AWS region of the S3 Bucket
    * `GCS_BUCKET_NAME`The name of the GCS Bucket
    * `AZURE_ACCOUNT_NAME`The name of the Azure account
    * `AZURE_ACCOUNT_KEY`The Azure account key
    * `AZURE_HOST_NAME`The Azure host name
    * `AZURE_CONTAINER_NAME`The Azure container name
    * `AWS_ACCESS_KEY_ID`The AWS access key
    * `AWS_SECRET_ACCESS_KEY`The AWS secret access key
    * `REDIS_HOST`The domain / IP of your redis instance
    * `REDIS_PORT`The port of your redis instance
    * `REDIS_PASSWORD`Optional password of your redis instance
    * `REDIS_DB_INDEX`The Redis database index
    * `REDIS_CACHE_SERVICE_HOST`The domain / IP of your redis instance for caching
    * `REDIS_CACHE_SERVICE_PORT`The port of your redis instance for caching
    * `REDIS_DB_INDEX`The Redis cache database index
    * `REDIS_CACHE_TTL`The Redis cache ttl
    * `REDIS_CACHE_PASSWORD`The Redis cache password
    * `REDIS_CACHE_CONNECTION_TIMEOUT`The Redis cache connection timeout
    * `REDIS_CACHE_KEEP_ALIVE`The Redis cache TCP keep alive on the socket timeout
    * `REDIS_CACHE_FAMILY`The Redis cache IP stack version
    * `REDIS_CACHE_KEY_PREFIX`The Redis cache prefix prepend to all keys
    * `REDIS_CACHE_SERVICE_TLS`The Redis cache TLS connection support
    * `IN_MEMORY_CLUSTER_MODE_ENABLED`The flag that enables the cluster mode. It might be Redis or ElastiCache cluster, depending on the env variables set for either service.
    * `ELASTICACHE_CLUSTER_SERVICE_HOST`ElastiCache cluster host
    * `ELASTICACHE_CLUSTER_SERVICE_PORT`ElastiCache cluster port
    * `REDIS_CLUSTER_SERVICE_HOST`Redis cluster host
    * `REDIS_CLUSTER_SERVICE_PORTS`Redis cluster ports
    * `REDIS_CLUSTER_DB_INDEX`Redis cluster database index
    * `REDIS_CLUSTER_TTL`Redis cluster ttl
    * `REDIS_CLUSTER_PASSWORD`Redis cluster password
    * `REDIS_CLUSTER_CONNECTION_TIMEOUT`Redis cluster connection timeout
    * `REDIS_CLUSTER_KEEP_ALIVE`Redis cluster TCP keep alive on the socket timeout
    * `REDIS_CLUSTER_FAMILY`Redis cluster IP stack version
    * `REDIS_CLUSTER_KEY_PREFIX`Redis cluster prefix prepend to all keys
    * `MONGO_URL`The URL of your MongoDB instance
    * `MONGO_MAX_POOL_SIZE`The max pool size of the MongoDB connection
    * `NEW_RELIC_APP_NAME`The New Relic app name
    * `NEW_RELIC_LICENSE_KEY`The New Relic license key
    * `SEGMENT_TOKEN`The Segment Analytics token
  </Accordion>

  <Accordion title="Web Client">
    * `REACT_APP_ENVIRONMENT` The environment of the app. Possible values are: dev, test, production, ci, local
    * `REACT_APP_API_URL` The base url on which your API backend would be accessible
    * `REACT_APP_WS_URL` The base url on which your WebSocket service would be accessible
    * `SKIP_PREFLIGHT_CHECK` (default: true)Solves a problem with React App dependency tree.

    <Warning>
      When configuring different than default values for the API and WebSocket URLs,
      in order for the Web app to apply the changes done to the `./env` file, it is
      needed to run the script `pnpm envsetup`. This will generate a file
      called `env-config.js` that will be copied inside of the `public` folder of
      the application. Its purpose is to inject in the `window._env_`object the
      chosen environment variables that manage the URLs the Web client will call to
      access to the API backend and the WebSocket service.
    </Warning>
  </Accordion>

  <Accordion title="Web Socket">
    * `NODE_ENV` (default: local)The environment of the app. Possible values are: dev, test, production, ci, local
    * `SENTRY_DSN`The DSN of sentry.io used to report errors happening in production
    * `REDIS_HOST`The domain / IP of your redis instance
    * `REDIS_PORT`The port of your redis instance
    * `REDIS_DB_INDEX`The database index of your redis instance
    * `REDIS_PASSWORD`Optional password of your redis instance
    * `JWT_SECRET`The secret keybase which is used to encrypt / verify the tokens issued for authentication
    * `MONGO_URL`The URL of your MongoDB instance
    * `MONGO_MAX_POOL_SIZE`The max pool size of the MongoDB connection
    * `PORT`The port on which the WebSocket service should listen on
  </Accordion>
</AccordionGroup>

### Running tests

After making changes, you can run the tests for the respective package using the appropriate CLI commands:

### API

To run the API tests, run the following command:

```shell theme={null}
npm run start:worker:test
npm run start:e2e:api
```

The tests create a new instance of Novu and a test db and run the tests against it. The test db is removed after all tests have finished running.

### Web

To run the front end tests for the web project using cypress you need to install localstack. The cypress tests perform E2E tests. To be able to perform E2E tests, you need to run the API service in the appropriate test environment.

Run the services in test env with the following commands:

```shell theme={null}
npm run start:web
npm run start:api:test
npm run start:worker:test
npm run start:ws:test
```

Run the cypress test suite with the following command:

```shell theme={null}
cd apps/web && npm run cypress:run
```

To open the cypress management window to debug tests, run the following commands:

```shell theme={null}
cd apps/web && npm run cypress:open
```

### Different ports used by the services

* **3000** - API
* **3002** - WebSocket Service
* **3003** - Webhook Service
* **3004** - Worker Service
* **4200** - Web Management UI
* **4701** - Iframe embed for notification center
* **4500** - Widget Service

### Testing providers

To run tests against the providers’ folder, you can use the `npm run test:providers` command.

### Local environment setup script (beta)

As an option in our script runner `Jarvis` we have made available an option to run [this script](https://github.com/novuhq/novu/blob/2f2abdcaaad8a7735e0a2d488607c3276c8975fd/scripts/dev-environment-setup.sh) that will automatically try to install all the dependencies needed to be able to run Novu locally, as the previous step of installing the project dependencies through `pnpm install`. When executing it inside `Jarvis`, you will need to have previously installed by yourself `git` and `node`, as we mentioned earlier on this page.

The script can be run on its own without any previous dependency installed, as it is prepared to execute the following tasks:

* Check the running OS in the local machine (currently only MacOSx and [GNU Linux](https://en.wikipedia.org/wiki/GNU/Linux_naming_controversy)supported)
* Install of OS dependencies (currently only MacOSx supported) -- MacOSx: It will execute the following tasks --- Will try to install or update [XCode](https://developer.apple.com/xcode/) (skippable step; though XCode installs `[git](https://git-scm.com/)` that is a required dependency for later) --- Will install [Rosetta](https://support.apple.com/en-gb/HT211861) for Apple CPUs --- Will set up some opinionated OS settings
* Will check if `[git](https://git-scm.com/)` is installed and if not will abort the operation
* Will make [ZSH](https://en.wikipedia.org/wiki/Z_shell) the default shell to be able to execute the next task
* Will (opinionatedly) install [Oh My Zsh!](https://ohmyz.sh/) (skippable task)
* Will (opinionatedly) install the [Homebrew](https://brew.sh/) package manager and will set up your local environment to execute it besides adding some casks
* Will (opinionatedly) install [NVM](https://github.com/nvm-sh/nvm) as a Node.js version manager
* Will install the required [Node.js](https://nodejs.org/en/) version to be able to [run Novu](https://github.com/novuhq/novu/blob/2f2abdcaaad8a7735e0a2d488607c3276c8975fd/package.json#L180)
* Will install [PNPM](https://pnpm.io/) as a package manager, required dependency for some of the tasks inside Novu's scripts
* Will install [Docker](https://www.docker.com/) as containerized application development tool
* Will install required databases [MongoDB](https://www.mongodb.com/) (Community version) and [Redis](https://redis.io/) through Homebrew
* Will install the [AWS CLI](https://aws.amazon.com/cli/) tool (not required to run Novu; it is a core maintainer used tool)
* Will create a local development domain `local.novu.co` in your local machine
* Will clone the Novu repository in your local machine (skippable step) to a selected folder `$HOME/Dev`

<Warning>
  This script has only been thoroughly tested in MacOSx. Little testing has been
  run in GNU Linux.
</Warning>

<Info>
  This script is not bullet-proof and some of the tasks have intertwined
  dependencies with each other. We have tried to make it as idempotent as
  possible but some loose knots will probably show because of conflicts between
  versions of the different dependencies. Please report to us any problem found
  and we will try to fix or assist though we do not have the resources to make
  it idempotent in every potential system and potential combinations
</Info>


# Windows
Source: https://v0.x-docs.novu.co/community/windows-machine-setup

Learn how to configure your local Windows machine to run Novu

## Setting up git

To set up git and create an access token for GitHub, suggested installing [GitHub Desktop](https://www.notion.so/Dev-Machine-Setup-98d274c80fa249b0b0be75b9a7a72acb?pvs=21) before.

## Development Environment

### Node & NVM

To easily manage multiple node versions you can use [NVM for Windows](https://github.com/coreybutler/nvm-windows) a (Node Version Manager alternative for Windows).

Download the .exe installation file for NVM for Windows [here](https://github.com/coreybutler/nvm-windows/releases).

After installing NVM for Windows, check that the installation is successfull and added to path by running `nvm -v` on a terminal.

<Note>
  After installing NVM, if you get `nvm: command not found` or see
  no feedback from your terminal after you type `nvm -v`, simply **close
  your current terminal, open a new terminal**, and try verifying again.
</Note>

Once nvm is installed and working you can install any version of Node using the syntax `nvm install vX.Y.Z` and to switch to a node version,
run `nvm use vX.Y.Z`. Novu requires node v20.8.1 or higher:

```shell theme={null}
nvm install v18.17.0
nvm use v18.17.0
```

### PNPM

For package management, we use [PNPM](https://pnpm.io/) instead of npm or yarn to speed up our install times and space efficiency. To install pnpm globally run:

```shell theme={null}
npm install -g pnpm
```

### MongoDB

for detailed instructions on installing MongoDB community edition on a Windows machine please refere to the MongoDB doc [here](https://www.mongodb.com/docs/manual/tutorial/install-mongodb-on-windows).

After installation, whether you have installed as a Windows service or just the binaries, ensure that the MongoDB instance is started before you proceed.

### Redis

To install Redis for local development you'll first need to enable WSL2 (Windows Subsystem for Linux). detailed instructions for installing
WSL can be found [here](https://learn.microsoft.com/en-us/windows/wsl/install)

If you have WSL installed and enabled, you can easily install Redis using the native procedure for the Linux distribution that you have installed.
for Ubuntu or Debian which is the default distro installed by WSL, use the following commands

1. First install `lsb-release`, `curl` and `gpg` if you do not already have them:

```shell theme={null}
sudo apt install lsb-release curl gpg
```

2. Add the repository to the apt index, update it, and then install:

```shell theme={null}
curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg

echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list

sudo apt-get update
sudo apt-get install redis
```

3. Lastly, start the Redis server like so:

```shell theme={null}
sudo service redis-server start
```

### Docker

Docker is not a requirement to run Novu on your local machine, but if you would prefer to use Docker, Follow the installation guide on [docker website](https://docs.docker.com/desktop/install/windows-install/) to install **Docker Desktop** on your Windows machine.

### AWS CLI

Follow the instructions to install the AWS CLI so you can use it to create env later on, based on existing S3 buckets:

[Installing or updating the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

You should get something like this:

<img alt="AWS CLI" />

If needed, see:

[Resolve "Unable to locate credentials" error in Amazon S3](https://aws.amazon.com/premiumsupport/knowledge-center/s3-locate-credentials-error/)

### Local dev domain (Optional)

This will allow you to use [local.novu.co](http://local.novu.co) instead of [localhost](http://localhost) when accessing the service on your machine.

Navigate to `C:\Windows\System32\drivers\etc` in the file explorer and open the `hosts` file with a text editor (like Notepad):

<Note>
  Note that this file can only be edited when running as an Administrator.
</Note>

And add the [local.novu.co](http://local.novu.co) domain and save.

```shell theme={null}
127.0.0.1       local.novu.co
```

### Code Editor

Feel free to install your favorite code editor. We supply licenses for [WebStorm](https://www.notion.so/WebStorm-7570ab1037bf494d88d0f9b544ae3b79?pvs=21), or you can [Visual Studio Code](https://code.visualstudio.com/download) if you prefer it.

### Productivity tools

* GitHub Desktop (Optional)

GitHub Desktop simplifies the development workflow and interaction with Git. [Download](https://desktop.github.com/) the client from their website.


# Bridge Endpoint
Source: https://v0.x-docs.novu.co/framework/concepts/endpoint



## Bridge Endpoint

Novu Framework requires a **single** `HTTP` endpoint (`/api/novu` or similar) to be exposed by your application. This endpoint is used to receive events from our Worker Engine.

You can view the Bridge Endpoint as a webhook endpoint that Novu will call when it needs to retrieve contextual information for a given subscriber and notification.

Using the `create-novu-app` command creates a Bridge application for you with a Bridge endpoint ready to go.

## The `serve` function

We offer framework specific wrappers in form of an exported `serve` function that abstracts away:

* Parsing the incoming request for `GET`, `POST`, `PUT` and `OPTIONS` requests
* HMAC header authentication
* Framework specific response and error handling

Currently, we offer `serve` functions for the following frameworks:

* [Next.js](/framework/sdk/frameworks/nextjs)
* [Express.js](/framework/sdk/frameworks/express)
* [Nuxt](/framework/sdk/frameworks/nuxt)
* [h3](/framework/sdk/frameworks/h3)
* [Remix](/framework/sdk/frameworks/remix)
* [Sveltekit](/framework/sdk/frameworks/sveltekit)

## Writing a custom `serve` function

If we currently don't support your framework, you can write a custom `serve` function like the following example:

```ts theme={null}
import { type Request, type Response } from 'express';
import { NovuRequestHandler, ServeHandlerOptions } from '@novu/framework';

export const serve = (options: ServeHandlerOptions): any => {
  const requestHandler = new NovuRequestHandler({
    frameworkName: 'express',
    ...options,
    handler: (
      incomingRequest: Request,
      response: Response,
    ) => ({
        method: () => incomingRequest.method,
        headers: (key) => {
            const header = incomingRequest.headers[key];
            return Array.isArray(header) ? header[0] : header;
        },
        queryString: (key) => {
                const qs = incomingRequest.query[key];
                return Array.isArray(qs) ? qs[0] : qs;
        },
        body: () => incomingRequest.body,
        url: () => new URL(incomingRequest.url, `https://${incomingRequest.headers.get("host") || ""}`),
        transformResponse: ({ body, headers, status }) => {
            Object.entries(headers).forEach(([headerName, headerValue]) => {
              response.setHeader(headerName, headerValue);
            });

            return response.status(status).send(body);
       },
    }),
  });

  return requestHandler.createHandler();
};
```


# Step Inputs
Source: https://v0.x-docs.novu.co/framework/concepts/inputs



Inputs are defined using [JSON Schema](/framework/recipes/json-schema), providing a strong run-time validation system for your workflows.

This ensures that you as the developer, and your non-technical peers are speaking the same language.
Those responsible for styling and copy can edit with confidence, knowing their changes are tested in code.

## Inputs vs Payload

**Inputs** - For Non-Technical Peers and Developers. Managed in the Novu Web UI, defined by developers and used by non-technical peers.

<Info>
  **Examples** - Color of a button, text of a button, should a section be shown, digest duration, static text content, the order of the email sections, and etc...
</Info>

**Payload Schema** - For Developers. Passed during the `novu.trigger` method, and controlled by the developer.

<Info>
  **Examples** - User ID, Post ID, Comment, Order ID, 2FA token and etc...
</Info>

## Step Inputs

[Step](/framework/concepts/steps) input schema is defining the input passed during the `step` method. Those inputs can be modified and persisted in the Novu Web UI.

The snippet below shows configuration for the Workflow payload schema and the Step input schema. If you don’t provide a schema, Typescript will infer the data type to `unknown`, reminding you of the best practice to specify your schema.

```tsx theme={null}
workflow('new-signup', async ({ step, payload }) => {
    await step.email(
      'send-email',
      async (inputs) => {
          return {
            subject: inputs.subjectTitle,
            body: render(<ReactEmailContent hideBanner={inputs.hideBanner} components={inputs.components} />),
        }
      }, {
	      // Learn about JSON Schema here: https://json-schema.org/specification
        inputSchema: {
	        // Always `object`
          type: 'object',
          // Specify the properties to validate. Supports deep nesting.
          properties: {
            hideBanner: { type: 'boolean', default: false },
            subjectTitle: { type: 'string' },
            // Allowing no code control over the component in the Web UI
            components: {
                type: "array",
                items: {
                    type: "string"
                },
                default: ["header", "cta-row", "footer"]
            }
          },
          // Specify the array of which properties are required.
          required: ['complianceFooter'],
          // Used to enforce full type strictness, with no rogue properties.
          additionalProperties: false,
		      // The `as const` is important to let Typescript know that this
		      // type won't change, enabling strong typing on `inputs` via type
		      // inference of the provided JSON Schema.
        } as const,
      });
});
```

Learn more about [JSON Schema here](https://json-schema.org/specification), including the powerful validation features to ensure your Content renders perfectly, every time.

<Note>
  Other validators, including Zod and more, coming soon.
  Any validator that supports transformation to JSON Schema can be added.
</Note>

## JSON Schema Examples

To Learn more about advanced examples, visit our [JSON Schema](/framework/recipes/json-schema) page.


# Payload
Source: https://v0.x-docs.novu.co/framework/concepts/payload



Workflow payload is the data passed during the `novu.trigger` method. This is useful for ensuring that the payload is correctly formatted and that the data is valid.

## Payload Schema

Payload schema is defining the payload passed during the `novu.trigger` method. This is useful for ensuring that the payload is correctly formatted and that the data is valid.

```tsx theme={null}
workflow('comment-on-post', async ({ step, payload }) => {
    await step.email(
      'send-email',
      async () => {
          return {
            subject: `You have a new comment from: ${payload.author_name}.`,
            body: render(<ReactEmailContent comment={payload.comment} />),
        }
      });
  },
  {
    payloadSchema: {
            // Always `object`
          type: 'object',
          // Specify the properties to validate. Supports deep nesting.
          properties: {
            post_id: { type: 'number' },
            author_name: { type: 'string' },
            comment: { type: 'string', maxLength: 200 },
          },
          // Specify the array of which properties are required.
          required: ['post_id', 'comment'],
          // Used to enforce full type strictness, with no rogue properties.
          additionalProperties: false,
		      // The `as const` is important to let Typescript know that this
		      // type won't change, enabling strong typing on `inputs` via type
		      // inference of the provided JSON Schema.
        } as const,
  },
);
```

## Passing Payload

Here is an example of the validated payload during trigger:

```tsx theme={null}
novu.trigger('comment-on-post', {
    to: 'subscriber_id',
    payload: {
        post_id: 1234,
        author_name: 'John Doe',
        comment: 'Looks good!'
    }
});
```


# Dev Studio
Source: https://v0.x-docs.novu.co/framework/concepts/studio



The Echo Dev Studio is a companion app to the Echo Client SDK. Its goal is to provide a local environment that lives near your code.

To launch the dev studio locally you can run: `npx novu-labs@latest echo` . The Dev Studio will be started by default on port 2022, and accessible via: `http://localhost:2022`

After successfully connecting the Studio to your local edge endpoint, you will be able to preview in real time any workflows and content defined in your code. This is ideal for quick prototyping, debugging, styling, and adjusting your workflows before syncing them to Novu Cloud.

### Inputs and Payload forms

You can quickly modify the step inputs and workflow payload to preview your workflow's different states and be generated with. This is helpful to quickly debug how the email will behave in case of a missing input, or iterate more complex content structures.

### Syncing State

Sync state to your Production or Development environment in Novu, is recommended to do via your CI pipeline. However, a sync can be made using the Dev Studio for quick experimentation.

Click on the `Sync` button at the top right corner of the navigation bar, and a Diff will be generated between your local and the Novu Cloud environments.

After inspecting the State Diff, and specifying the remote `Echo Url` Click on the `Deploy Changes` button.

### **Debugging locally**

To allow Novu to communicate with your local machine a tunnel will need to be generated. The quickest way to do it is with `localtunnel.` To Create a new tunnel in your terminal, type: `npx localtunnel --port <YOUR_EDGE_PORT>` . This command will return an https endpoint, which then can be used during the sync state flow described earlier.


# Workflows
Source: https://v0.x-docs.novu.co/framework/concepts/workflows

Workflows are at the core of responding to events in your system with notifications. Novu Framework enables you to declare type-safe, validated, and version-controlled Novu Workflows with code.

## Introduction

The most basic Workflow to send a notification in response to an event looks like:

```tsx theme={null}
import { workflow } from '@novu/framework';

const myWorkflow = workflow('new-signup', async ({ step, payload }) => {
	// Send a welcome email
  await step.email('send-email', async () => {
    return {
      subject: `Welcome to Acme, ${payload.name}`,
      body: 'We look forward to helping you achieve mission.',
    }
  });
  // JSON Schema for validation and type-safety. Zod, and others coming soon.
}, { payloadSchema: { properties: { name: { type: 'string' }}}} );
```

## Just-in-time data fetching

You can add any custom logic into your steps that you need. Maybe you’d like to fetch some information about your new sign-up from somewhere else during the Workflow execution. You can achieve it with the following changes:

```tsx theme={null}
const myWorkflow = workflow('new-signup', async ({ step, payload }) => {
	// Send a welcome email
  await step.email('send-email', async () => {
	  // Fetch the user from your database
	  const user = await db.getUser(payload.userId);
        return {
          subject: `Welcome to Acme ${user.productTier} tier, ${user.name}.`,
          // 'Welcome to Acme Business tier, John Doe.'
          body: 'We look forward to helping you achieve mission.',
        }
      });
      // Changing the schema from `name` -> `userId`, for type-safety.
    }, { payloadSchema: { properties: { userId: { type: 'string' }}}} );
```

We call this **just-in-time** notification data fetching. It allows you pull in data from the relevant sources during the Workflow execution, removing the need to store all of your subscriber data in Novu.

## Multi-step workflow

Now, what if you wanted to send another update to the same new user in 1 week? But, you don't want to send the follow-up if the User opted out. We can add more steps to the Workflow to achieve this.

```tsx theme={null}
const myWorkflow = workflow(
  'new-signup',
  async ({ step, payload }) => {
    await step.email('send-email', async () => {
      const user = await db.getUser(payload.userId);
      return {
        subject: `Welcome to Acme ${user.productTier} tier, ${user.name}.`,
        body: 'We look forward to helping you achieve mission.',
      };
    });

    // Wait for 1 week before continuing. After 1 week, Novu will continue
    // executing the Workflow from here.
    await step.delay('onboarding-follow-up', async () => ({
      amount: 1,
      type: 'regular',
      unit: 'weeks',
    }));

    // 1 week passed, let's follow up with an in-app notification.
    await step.inApp(
      'onboarding-follow-up',
      async (inputs) => {
        const user = await db.getUser(payload.userId);
        // The `feedbackUrl` can be updated in Novu Web without changing code.
        // This helps you to create re-usable Workflow snippets.
        return {
          body: `Hey ${user.name}! How do you like the product?

      Let us know <a href="${inputs.feedbackUrl}">here</a>
      if you have any questions.`,
        };
      },
      {
        // Don't follow up if the Subscriber opted out.
        skip: () => !payload.shouldFollowUp,
        // Add validation to ensure `feedbackUrl` provided in Web is a `uri`
        inputSchema: {
          type: 'object',
          properties: { feedbackUrl: { type: 'string', format: 'uri', default: 'https://acme.com/feedback' } },
          required: ['feedbackUrl'],
          additionalProperties: false,
        } as const,
      },
    );
  },
  {
    payloadSchema: {
      type: 'object',
      properties: {
        userId: { type: 'string' },
        shouldFollowUp: { type: 'boolean', default: true },
      },
      required: ['userId', 'shouldFollowUp'],
      additionalProperties: false,
    } as const,
  },
);
```

With this simple Workflow, we:

* Sent a new signup email
* Waited 1 week
* Sent an in-app follow-up notification

You should now have a grasp of the flexibility that Novu Framework offers.

Continue your reading in [Steps](/framework/concepts/steps) to find out the other channels and actions you can use with Novu Framework.

## Workflow Interface

```tsx theme={null}
workflow(
	// the Workflow name. Must be unique across your Bridge server.
	'new-signup',
	// Workflow resolver, the entry-point for your Workflow steps
	async ({
		// Helper function to declare your Workflow Steps.
		step,
		// Workflow Trigger payload
		payload,
	}) => {
	// ...your Workflow Steps

}, {
	// JSON Schema for validation and type-safety. Zod, and others coming soon.
	// https://json-schema.org/draft-07/json-schema-release-notes

	// The schema for the Workflow payload passed dynamically via Novu Trigger API
	// Defaults to an empty schema.
	payloadSchema: { properties: { name: { type: 'string' }}},
	// The schema for the Workflow inputs passed statically via Novu Web
	// Defaults to an empty schema.
	inputSchema: { properties: { brandColor: { type: 'string' }}},
});
```


# GitHub Actions
Source: https://v0.x-docs.novu.co/framework/deployment/actions



You can also deploy the workflow state with our built-in GitHub Action command:

```yaml theme={null}
name: Deploy Workflow State to Novu

on:
  push:
    branches:
      - main
jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2
		  - name: Sync State to Novu
		    uses: novuhq/actions-novu-sync@v0.0.4
		    with:
		      novu-api-key: ${{secrets.NOVU_API_KEY}} # Your Dev or Prod API Key to Novu
		      bridge-url: "" # This will be your target environment bridge url
```


# CLI
Source: https://v0.x-docs.novu.co/framework/deployment/cli



The Echo CLI provides a mechanism for you to synchronize your Workflows into Novu Cloud so that non-technical Novu Users can control the Workflow and Step-level inputs and enable your Workflows to be triggered via Novu API.

```bash theme={null}
npx novu-labs@latest sync --echo-url <YOUR URL> --api-key <NOVU_API_KEY>
```


# Going to Production
Source: https://v0.x-docs.novu.co/framework/deployment/production



Novu operates in a multi environment setup. Currently Novu Supports 2 environments:

* **Development** - This is the environment where the development team works on workflows.
* **Production** - This is the environment that is used to trigger workflows to your customers.

## Pushing changes to Cloud

Novu Framework operates in a GitOps model. This means that the source of truth for your workflows and configurations are located in your Git as Code.

The general workflow for pushing changes to Cloud is as follows:

* Create a feature branch
* Develop workflows locally in your Bridge application
* Sync changes to the Development environment to test e2e
* Merge the feature branch to your `dev` branch
  * This will trigger a CI/CD pipeline that will deploy the changes to the Development environment
* Test the changes in the Development environment
* Merge the `dev` branch to the `main` branch
  * This will trigger a CI/CD pipeline that will deploy the changes to the Production environment

## Networking

Novu Cloud workers will need to be able to communicated with your Bridge Endpoint. You will need to ensure that your firewall rules allow traffic from the internet.
Due to the autoscaling nature of Novu Cloud, we don't have a set of IP Addresses that you can whitelist.

## Security

Novu Cloud workers are GDPR, SOC2 type II and ISO 27001 compliant. We take security very seriously and have implemented a number of security measures to ensure that your data is safe.
Novu Framework has a builtin security mechanism that ensures that the requests are authentic from Novu Cloud using an HMAC signature.

HMAC Verification is turned on by default

```typescript theme={null}
export const client = new Client({
  apiKey: process.env.NOVU_API_KEY,,
  strictAuthentication: process.env.NODE_ENV !== "development", // set to true by default
});
```

<Info>
  For local development with Studio `strictAuthentication` should be set to `false`.
</Info>

The `X-Novu-Signature` header included in each signed event contains a timestamp and one or more signatures that we verify.
The timestamp is prefixed by t=, and each signature is prefixed by a scheme.
Schemes start with v, followed by an integer. Currently, the only valid live signature scheme is v1.

Handling the signature verification is done by the Novu Framework, you don't need to perform any action.

## CI/CD Integrations

Novu currently supports the following CI integrations:

* **GitHub Actions** - [Direct Integration](/framework/deployment/actions)
* **GitLab CI** - Using our [CLI command](/framework/deployment/cli)
* **Jenkins** - Using our [CLI command](/framework/deployment/cli)
* **CircleCI** - Using our [CLI command](/framework/deployment/cli)
* **Bitbucket Pipelines** - Using our [CLI command](/framework/deployment/cli)
* **Azure DevOps** - Using our [CLI command](/framework/deployment/cli)
* **Travis CI** - Using our [CLI command](/framework/deployment/cli)
* **Other** - For any other CI/CD tool, you can use our [CLI command](/framework/deployment/cli)

<Info>
  Direct integration with other CI/CD tools is on our roadmap. If you would like to see a specific CI/CD tool integrated, please reach out to us.
</Info>


# React E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/react-email



Integrating Novu Framework with [React.Email](https://react.email/) for your Next.js application can be done in three steps. If you don't have an app, you can create one with the `create-novu-app` command.

<Steps>
  <Step title="Install React.Email components">
    Install the required React.Email components.

    ```bash theme={null}
      npm i @react-email/components react-email
    ```
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.tsx` file for your email template.

    ```tsx theme={null}
    import * as React from "react";
    import { Button, Html } from "@react-email/components";

    function Email(props) {
      return (
        <Html>
          <Button
            href="https://example.com"
            style={{ background: "#000", color: "#fff", padding: "12px 20px" }}
          >
            Click me
          </Button>
        </Html>
      );
    }

    export function renderEmail(inputs) {
      return render(<Email {...inputs} />);
    }
    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```tsx theme={null}
    import { renderEmail } from './sample-email.tsx';
    import { workflow } from '@novu/framework';

    workflow('new-signup', async ({ step, payload }) => {
      await step.email('send-email', async (inputs) => {
        return {
          subject: `Welcome to React E-mail`,
          body: renderEmail(inputs),
        }
      });
    });
    ```
  </Step>
</Steps>


# Remix w/ React E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/remix-react-email



Integrating Novu Framework with [React email](https://react.email/) for your Remix application can be done in three steps. If you don't have an app, you can [clone our Remix example](https://github.com/novuhq/novu-framework-remix-example).

<Steps>
  <Step title="Install React email components">
    Install the required React email components.

    ```bash theme={null}
      npm i @react-email/components react-email
    ```
  </Step>

  <Step title="Create email templates folder">
    Create an `emails` folder in the `app` directory of your Remix app.
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.tsx` file for your email template.

    ```ts theme={null}
    import { Button, Html } from "@react-email/components";

    function Email(props) {
      return (
        <Html>
          <Button
            href="https://example.com"
            style={{ background: "#000", color: "#fff", padding: "12px 20px" }}
          >
            Click me
          </Button>
        </Html>
      );
    }

    export function renderEmail(inputs) {
      return render(<Email {...inputs} />);
    }
    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```tsx theme={null}
    import { renderEmail } from './sample-email.tsx';
    import { workflow } from '@novu/framework';

    workflow('new-signup', async ({ step, payload }) => {
      await step.email('send-email', async (inputs) => {
        return {
          subject: `Welcome to Remix and React E-mail`,
          body: renderEmail(inputs),
        }
      });
    });
    ```
  </Step>
</Steps>


# Svelte E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/svelte-email



Integrating Novu Framework with [Svelte email](https://react.email/) for your Svelte application can be done in three steps. If you don't have an app, you can [clone our Svelte example](https://github.com/novuhq/novu-svelte-email).

<Steps>
  <Step title="Install Svelte email components">
    Install the required Svelte email components.

    ```bash theme={null}
      npm i svelte-email
    ```
  </Step>

  <Step title="Create email templates folder">
    Create an `emails` folder in the `src/lib` directory of your Svelte app.
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.svelte` file for your email template.

    ```ts theme={null}
    <script lang="ts">
        import { Button, Container, Head, Hr, Html, Img, Preview, Section, Text } from 'svelte-email';

        export let firstName = 'John';

        const fontFamily =
            '-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen-Sans,Ubuntu,Cantarell,"Helvetica Neue",sans-serif';

        const main = {
            backgroundColor: '#ffffff'
        };

        const container = {
            margin: '0 auto',
            padding: '20px 0 48px'
        };

        const logo = {
            margin: '0 auto'
        };

        const paragraph = {
            fontFamily,
            fontSize: '16px',
            lineHeight: '26px'
        };

        const btnContainer = {
            textAlign: 'center' as const
        };

        const button = {
            fontFamily,
            backgroundColor: '#5F51E8',
            borderRadius: '3px',
            color: '#fff',
            fontSize: '16px',
            textDecoration: 'none',
            textAlign: 'center' as const,
            display: 'block'
        };

        const hr = {
            borderColor: '#cccccc',
            margin: '20px 0'
        };

        const footer = {
            fontFamily,
            color: '#8898aa',
            fontSize: '12px'
        };
    </script>

    <Html lang="en">
        <Head />
        <Preview preview="Welcome to svelte-email" />
        <Section style={main}>
            <Container style={container}>
                <Img
                    src="https://svelte.dev/svelte-logo-horizontal.svg"
                    alt="Svelte logo"
                    style={logo}
                    width="200"
                    height="50"
                />
                <Text style={paragraph}>{firstName}, welcome to svelte-email</Text>
                <Text style={paragraph}>A Svelte component library for building responsive emails</Text>
                <Section style={btnContainer}>
                    <Button pX={12} pY={12} style={button} href="https://github.com/carstenlebek/svelte-email">
                        View on GitHub
                    </Button>
                </Section>
                <Text style={paragraph}>Happy coding!</Text>
                <Hr style={hr} />
                <Text style={footer}>Carsten Lebek</Text>
            </Container>
        </Section>
    </Html>
    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```tsx theme={null}
    import WelcomeEmail from '$lib/emails/sample-email.svelte';
    import { render } from 'svelte-email';
    import { workflow } from '@novu/framework';

    workflow('new-signup', async ({ step, payload }) => {
        await step.email(
            'send-email',
            async (inputs) => {
                const html = render({
                    template: WelcomeEmail,
                    props: {
                        firstName: 'John',
                    },
                });
                return {
                    subject: `Welcome to Svelte E-mail`,
                    body: html,
                }
            });
        }
    );
    ```
  </Step>
</Steps>


# Vue E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/vue-email



You can integrate Novu Framework with [Vue Email](https://vuemail.net/) in a few simple steps. This guide will walk you through the process of creating a new email template using Vue Email and Nuxt.

For a Quickstart Boilerplate project using Nuxt.js, and Vue Email, check out the [Vue Email Starter repository](https://github.com/novuhq/novu-framework-nuxt-example/)

## Quickstart

<Steps>
  <Step title="Install Vue.Email components">
    Install the required Vue.Email components.

    ```bash theme={null}
    npm install vue-email @vue-email/compiler @vue-email/nuxt
    ```
  </Step>

  <Step title="Create templates folder">
    Create a `templates` folder in the root of your Nuxt app
  </Step>

  <Step title="Update nuxt.config.ts File">
    Update your `nuxt.config.ts` file to include the Vue Email module.

    ```ts nuxt.config.ts theme={null}
    export default defineNuxtConfig({
        devtools: { enabled: true },
        components: true,

        modules: [
            '@vue-email/nuxt',
        ],
    })
    ```
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.vue` file in the `templates` folder for your email template.

    ```vue theme={null}
    <script setup lang="ts">
        import { defineProps, withDefaults } from 'vue'

        interface Props {

        }

        const baseUrl = "https://react-email-demo-bdj5iju9r-resend.vercel.app";

        const props = withDefaults(defineProps<Props>(), {});
    </script>

    <template>
        <ETailwind>
            <EHtml>
                <EHead/>
                <EPreview>Email Preview Text</EPreview>
                <EBody class="bg-white my-auto mx-auto font-sans">
                    <EContainer class="border border-solid border-[#eaeaea] p-[20px] md:p-7 rounded my-[40px] mx-auto max-w-[465px]">
                        <EHeading class="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
                            Hello World!
                        </EHeading>
                    </EContainer>
                </EBody>
            </EHtml>
        </ETailwind>
    </template>

    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```ts theme={null}
    import { config } from '@vue-email/compiler';
    import { workflow } from '@novu/framework';

    const vueEmail = config('templates', {
        verbose: false,
        options: {},
    });


    workflow('new-signup', async ({step, payload}) => {
        await step.email('send-email', async (inputs) => {
            const template = await vueEmail.render('sample-email.vue', {
                props: inputs
            })

            return {
                subject: `Welcome to Vue E-mail`,
                body: template.html
            }
        });
    });
    ```
  </Step>
</Steps>

## Learn More

To learn more, refer to [Vue Email documentation](https://vuemail.net/).


# No-Code Tools to control your Notification Flows
Source: https://v0.x-docs.novu.co/framework/non-developers/introduction

Change notification content and behavior with confidence using Novu Web UI.

Novu Framework was designed to bridge the gap between developers and on-developers in the team.

* **Developers** - Define and abstract away complex logic, data manipulation and hydration, html and etc...
* **Non-Developers** - Use the Novu Web UI to control the content and behavior of the notifications using [Inputs](/framework/concepts/inputs).

## How to Modify Inputs?

Inputs are modified directly on the [Novu Web UI](https://web.novu.co). Each Workflow editor page have an 'Inputs' tab where you can modify them.
When Saving the changes, the new Input values will be used in the notification sent to your subscriber.

## Common Input Usecases

### Change Notification Content

An input can be as broad as `content` or as specific as `2fa_code_title_color`. This allows you to change the content of the notification without needing to touch the code.

<Tip>
  Currently you cannot use Dynamic payload variables as part of the Input. Reach out to us if you need this capability.
</Tip>

### Change Digest or Delay Frequency

Inputs can be used for controlling any aspect of the step configuration, for example:

* Digest Length
* Delay Amount
* Digest Type (Daily, Weekly, Monthly)
* etc...

### Control structure and layout

Inputs can be used to show/hide or rearrange the layout of the notification.
For example, you can have an input to show/hide a button, or change the position of a specific email section.


# Quick Start
Source: https://v0.x-docs.novu.co/framework/quickstart

Novu Framework, the Code-first notification workflow engine. Build advanced workflows while giving your non-technical teammates complete control over content and behavior.

<Note>
  **Novu Framework is currently in public Alpha.** Need help? Have a suggestion? Join our [Discord community](https://discord.gg/novu).
</Note>

## Introduction to Novu Framework

Novu Framework allows you to write notification workflows in your codebase. Workflows are functions that execute business logic and use your preferred libraries for email, SMS, and chat generation. You can use Novu Framework with [React.Email](https://react.email/), [MJML](https://mjml.io/), or any other template generator.

<EchoTerminal />

## Try it now

To create a new Bridge application that will allow you to define your workflow in code, open your terminal and execute the `create-novu-app` command.

```shell theme={null}
npx create-novu-app@latest --api-key=<API_KEY_HERE>
```

The command will ask you if you wish to install from a React.Email template or a clean project.

## Core features

<CardGroup>
  <Card title="Bring Your Own Code" icon="code">
    Write the notification workflows as functions in your codebase,  version, and manage them using Git.
  </Card>

  <Card title="Limitless Integrations" icon="plug" href={'/framework/integrations'}>
    Use React.email, MJML, or fetch templates from Braze, Hubspot, Sendgrid, and more...
  </Card>

  <Card title="Type Safety" icon="shield">
    Bring your own schemas for full, end-to-end validation and type safety.
  </Card>

  <Card title="Cloud Synchronization" icon="cloud">
    Sync your workflows with Novu Cloud and ease collaboration.
  </Card>
</CardGroup>

## How it Works?

Novu Framework introduces a new paradigm when working with Novu. Rather than defining workflows and templates at Novu Cloud, Novu Framework enables you to work in your application, use your own libraries and connect to your production environment during workflow execution over HTTPS.

The Novu Framework exports the client you use to define and serve your workflows and their steps over HTTPS. The workflows can be added to your preferred framework. During workflow execution Novu Cloud makes HTTPS requests to your Bridge server for *just-in-time* Content and Subscribers resolution.

<Frame>
  <img />
</Frame>

## For Non-Technical Users

Novu Framework was built with non-technical user in mind. Engineers can write complex workflows and expose a type-safe [Inputs](/framework/concepts/inputs) interface powered by JSON-Schema.
This enables Non-Technical teammates to safely modify the workflow without breaking mission critical notifications.


# JSON Schema
Source: https://v0.x-docs.novu.co/framework/recipes/json-schema



JSON Schema can be used to define the [Workflow Payload](/framework/concepts/inputs) and [Step Inputs](/framework/concepts/inputs).
It provides a strongly-typed way to define the structure of the data that is expected by the Workflow or Step.
And also as a contract for changing the Workflow behaviour using the Platform User Interface.

Learn more about JSON Schema at [json-schema.org](https://json-schema.org/).

## Examples

### Simple

```json theme={null}
{
  "type": "object",
  "required": [
    "firstName",
    "lastName"
  ],
  "properties": {
    "firstName": {
      "type": "string",
      "title": "First name",
      "default": "Chuck"
    },
    "lastName": {
      "type": "string",
      "title": "Last name"
    },
    "age": {
      "type": "integer",
      "title": "Age"
    }
  }
}
```

### Nested Array Structure

```json theme={null}
{
  "type": "object",
  "required": [
    "title"
  ],
  "properties": {
    "title": {
      "type": "string",
      "title": "Task list title"
    },
    "tasks": {
      "type": "array",
      "title": "Tasks",
      "items": {
        "type": "object",
        "required": [
          "title"
        ],
        "properties": {
          "title": {
            "type": "string",
            "title": "Title",
            "description": "A sample title"
          },
          "details": {
            "type": "string",
            "title": "Task details",
            "description": "Enter the task details"
          },
          "done": {
            "type": "boolean",
            "title": "Done?",
            "default": false
          }
        }
      }
    }
  }
}
```

### Reference and Reuse Blocks

```json theme={null}
{
  "definitions": {
    "address": {
      "type": "object",
      "properties": {
        "street_address": {
          "type": "string"
        },
        "city": {
          "type": "string"
        },
        "state": {
          "type": "string"
        }
      },
      "required": [
        "street_address",
        "city",
        "state"
      ]
    },
    "node": {
      "type": "object",
      "properties": {
        "name": {
          "type": "string"
        },
        "children": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/node"
          }
        }
      }
    }
  },
  "type": "object",
  "properties": {
    "billing_address": {
      "title": "Billing address",
      "$ref": "#/definitions/address"
    },
    "shipping_address": {
      "title": "Shipping address",
      "$ref": "#/definitions/address"
    },
    "tree": {
      "title": "Recursive references",
      "$ref": "#/definitions/node"
    }
  }
}
```

### Any Of Schemas

```json theme={null}
{
  "type": "object",
  "properties": {
    "age": {
      "type": "integer",
      "title": "Age"
    },
    "items": {
      "type": "array",
      "items": {
        "type": "object",
        "anyOf": [
          {
            "properties": {
              "foo": {
                "type": "string"
              }
            }
          },
          {
            "properties": {
              "bar": {
                "type": "string"
              }
            }
          }
        ]
      }
    }
  },
  "anyOf": [
    {
      "title": "First method of identification",
      "properties": {
        "firstName": {
          "type": "string",
          "title": "First name",
          "default": "Chuck"
        },
        "lastName": {
          "type": "string",
          "title": "Last name"
        }
      }
    },
    {
      "title": "Second method of identification",
      "properties": {
        "idCode": {
          "type": "string",
          "title": "ID code"
        }
      }
    }
  ]
}
```

### One Of Schema

```json theme={null}
{
  "type": "object",
  "oneOf": [
    {
      "properties": {
        "lorem": {
          "type": "string"
        }
      },
      "required": [
        "lorem"
      ]
    },
    {
      "properties": {
        "ipsum": {
          "type": "string"
        }
      },
      "required": [
        "ipsum"
      ]
    }
  ]
}
```

### If Then Else

```json theme={null}
{
  "type": "object",
  "properties": {
    "animal": {
      "enum": [
        "Cat",
        "Fish"
      ]
    }
  },
  "allOf": [
    {
      "if": {
        "properties": {
          "animal": {
            "const": "Cat"
          }
        }
      },
      "then": {
        "properties": {
          "food": {
            "type": "string",
            "enum": [
              "meat",
              "grass",
              "fish"
            ]
          }
        },
        "required": [
          "food"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "animal": {
            "const": "Fish"
          }
        }
      },
      "then": {
        "properties": {
          "food": {
            "type": "string",
            "enum": [
              "insect",
              "worms"
            ]
          },
          "water": {
            "type": "string",
            "enum": [
              "lake",
              "sea"
            ]
          }
        },
        "required": [
          "food",
          "water"
        ]
      }
    },
    {
      "required": [
        "animal"
      ]
    }
  ]
}
```

### Enum Objects

```json theme={null}
{
  "definitions": {
    "locations": {
      "enumNames": [
        "New York",
        "Amsterdam",
        "Hong Kong"
      ],
      "enum": [
        {
          "name": "New York",
          "lat": 40,
          "lon": 74
        },
        {
          "name": "Amsterdam",
          "lat": 52,
          "lon": 5
        },
        {
          "name": "Hong Kong",
          "lat": 22,
          "lon": 114
        }
      ]
    }
  },
  "type": "object",
  "properties": {
    "location": {
      "title": "Location",
      "$ref": "#/definitions/locations"
    },
    "locationRadio": {
      "title": "Location Radio",
      "$ref": "#/definitions/locations"
    },
    "multiSelect": {
      "title": "Locations",
      "type": "array",
      "uniqueItems": true,
      "items": {
        "$ref": "#/definitions/locations"
      }
    },
    "checkboxes": {
      "title": "Locations Checkboxes",
      "type": "array",
      "uniqueItems": true,
      "items": {
        "$ref": "#/definitions/locations"
      }
    }
  }
}
```

### Regex Validation

The following example matches a simple North American telephone number with an optional area code:

```json theme={null}
{
  "type": "object",
  "properties": {
    "phone": {
      "type": "string",
      "pattern": "^(\\([0-9]{3}\\))?[0-9]{3}-[0-9]{4}$"
    }
  }
}
```

## Other Resources

* [Examples](https://json-schema.org/learn/miscellaneous-examples)
* [React JSON Schema](https://rjsf-team.github.io/react-jsonschema-form/)
* [JSON Schema Validator](https://www.jsonschemavalidator.net/)
* [JSON Schema Lint](https://jsonschemalint.com/)


# Roadmap
Source: https://v0.x-docs.novu.co/framework/roadmap



This document outlines the roadmap for the Novu Framework project. It is a living document and will be updated as the project progresses.

Our goal with Novu Framework is to create a Code-First but Product in-mind. Here you can see parts of our roadmap and future plans for it:

Looking to add a feature request or upvote and existing feature? Head over to our [Public Roadmap](https://roadmap.novu.co).

## Novu Framework, Now and Next

* ✅ **Workflows**: the ability to create multi-step workflows and manage them using Code.
* ✅ **CLI**: a command-line interface to interact with Novu Framework.
* ✅ **Studio**: a visual front to preview your local work.
* ✅ **Step Inputs**: JSON-Schema based interface for not technical users to modify the workflow content and behaviour.
* ✅ **GitHub Actions**: sync your workflows using GitHub Actions.
* ✅ **In App Seen/Read**: the ability to see the status of the in-app message.
* ✅ **Custom Step**: the ability to create custom and execute custom code in the workflow. For example: custom provider, retrieving database information, and 3rd party service integration.
* 🔜 **Zod Schema**: the ability to define the schema for the workflow and step inputs using Zod.
* 🔜 **Define Integrations**: code-first approach of creating and managing your provider integrations
* 🔜 **Email Reply Hook**: executing a custom logic code when a user replies to the email.
* 🔜 **Webhook**: receive webhooks about the execution flow of a workflow in Novu Framework.
* 🔜 **Eslint Plugin**: follow best practices and avoid common mistakes when writing code for Novu Framework.
* 🔜 **Codegen**: use our community driven list of workflow templates to use out of the box.


# Introduction
Source: https://v0.x-docs.novu.co/framework/sdk/client



See the snippet below to learn how to configure your Bridge endpoint application.

```tsx theme={null}
import { Client } from '@novu/framework';

const client = new Client({
  /**
   * Specify a custom Novu API URL.
   * Defaults to 'https://api.novu.co', for EU use: https://eu.api.novu.co
   */
	apiUrl: 'https://api.novu.co',
  /**
   * Specify your Novu API key, to secure your Bridge API endpoint.
   * Novu communicates securely with your endpoint using a signed HMAC header,
   * ensuring that only trusted requests from Novu are actioned by your Bridge API.
   * The API key is used to sign the HMAC header.
   */
	apiKey: process.env.NOVU_API_KEY,
  /**
   * Explicitly use HMAC signature verification.
   * Setting this to `false` will enable Novu to communicate with your Bridge API
   * without requiring a valid HMAC signature.
   * This is useful for local development and testing.
   *
   * You are strongly encouraged to specify an `apiKey` and set this to `true` in production,
   * to ensure that only trusted requests from Novu are actioned by your Bridge API.
   *
   * Defaults to true.
   */
	strictAuthentication: process.env.NODE_ENV !== "development",
});
```


# Integrate Novu with Express.js
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/express



```tsx theme={null}
import { serve } from "@novu/framework/express";
import { myWorkflow } from "../novu/workflows";

app.use(express.json()); // Required for Novu POST requests
app.use(
  "/api/novu",
  serve({ workflows: [myWorkflow] })
);
```


# Integrate Novu with H3
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/h3



```tsx theme={null}
import { createApp, eventHandler, toNodeListener } from "h3";
import { serve } from "@novu/framework/h3";
import { createServer } from "node:http";
import { myWorkflow } from "./novu/workflows";

const app = createApp();
app.use(
  "/api/novu",
  eventHandler(
    serve({
      workflows: [myWorkflow],
    })
  )
);

createServer(toNodeListener(app)).listen(process.env.PORT || 3000);
```


# Integrate Novu with Next.js
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/nextjs



## App Router

<CodeGroup>
  ```ts app/api/novu/route.ts theme={null}
  import { serve } from "@novu/framework/next";
  import { myWorkflow } from "../../novu/workflows";

  export const { GET, POST, PUT, OPTIONS } = serve({ workflows: [myWorkflow] });
  ```
</CodeGroup>

## Pages Router

<CodeGroup>
  ```ts pages/api/novu.ts theme={null}
  import { serve } from "@novu/framework/next";
  import { myWorkflow } from '../../novu/workflows';

  export default serve({ workflows: [myWorkflow] });
  ```
</CodeGroup>

Check out a comprehensive [guide on sending notifications in Next.js with React email](/guides/framework-guides/framework-react-email).


# Integrate Novu with Nuxt
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/nuxt



Novu Framework works out of the box with Nuxt.js. You can use the `@novu/framework/nuxt` package to serve your Bridge endpoint in your Nuxt.js application.

For a boilerplate project with Vue Email, view: [Nuxt.js Boilerplate](https://github.com/novuhq/novu-framework-nuxt-example/)

<CodeGroup>
  ```ts API Routes theme={null}
  import { serve } from "@novu/framework/nuxt";
  import { myWorkflow } from "../workflows";

  export default defineEventHandler(serve({ workflows: [myWorkflow] }));
  ```
</CodeGroup>

Check out a comprehensive [guide on sending notifications in Nuxt with Vuemail](/guides/framework-guides/framework-nuxt-vuemail).


# Integrate Novu with Remix
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/remix



```tsx theme={null}
import { serve } from "@novu/framework/remix";
import { myWorkflow } from "../novu/workflows";

const handler = serve({
    workflows: [myWorkflow],
  });
  
export { handler as action, handler as loader };
```

Check out a comprehensive [guide on sending notifications in Remix with React email](/guides/framework-guides/framework-remix).


# Integrate Novu with SvelteKit
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/sveltekit



```tsx theme={null}
import { myWorkflow } from '../workflows';
import { serve } from '@novu/framework/sveltekit';

export const { GET, POST, PUT } = serve({ workflows: [myWorkflow] });
```

Check out a comprehensive [guide on sending notifications in Svelte with Svelte-email](/guides/framework-guides/framework-svelte).


# Typescript
Source: https://v0.x-docs.novu.co/framework/sdk/typescript



Novu Framework was built and optimized for extreme focus on Developer Experience.
Our `@novu/framework` SDK is written in Typescript, and we recommend using Typescript for your own projects as well.

<EchoTerminal />

## Type Safe Workflow Payloads

When defining a [workflow payload](/framework/concepts/payload) schema, our SDK will automatically infer it to a Typescript interface.

```typescript theme={null}
import { workflow } from '@novu/framework';

const myWorkflow = workflow('new-signup', async ({ step, payload }) => {
	await step.email('send-email', () => {
        return {
            subject: 'Hello World',
            // The payload object here is type-safe
            body: `Hi ${payload.name}, welcome to our platform!`
        }
	});
}, {
	// JSON Schema for validation and type-safety. Zod, and others coming soon.
	// https://json-schema.org/draft-07/json-schema-release-notes
	payloadSchema: { properties: { name: { type: 'string' }}},
});
```

## Type Safe Steps

Similarly, when defining a [step](/framework/concepts/steps) schema, our SDK will automatically infer it to a Typescript interface.


# Chat Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/chat



Use the chat channel step to send a message for providers like: Slack, WhatsApp, Discord and others.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
});
```

## Provider Overrides

Some providers offer a rich DSL for styling the messages. Novu Framework offers a robust API to leverage the provider specific capabilities using the step `providers` option object.

Let's see an example of how to send a message to Slack using the `providers` option objet.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
}, {
    providers: {
        slack: ({ inputs }) => ({
            text: 'A new post has been created',
            blocks: [
                {
                    type: 'section',
                    text: {
                        type: 'mrkdwn',
                        text: 'A new post has been created',
                    },
                },
            ],
        }),
    }
});
```

Default chat `body` field is still specified as a fallback value in case a provider specific configuration is not used.

<Info>
  Currently we only support `Slack` provider overrides. We are working on adding more providers.
</Info>


# Custom Action Step
Source: https://v0.x-docs.novu.co/framework/steps/custom

Used to execute any custom code as a step in the workflow.

A custom steps allows to execute any custom logic and persist in the durable execution context. The result of this step can be used in subsequent steps.

## Common usecases

* Making an API call to 3rd party service
* Fetch data from a database to be used in subsequent steps
* Execute a custom logic to transform data
* Custom provider implementation

## Custom Step Interface

```tsx theme={null}
const stepResult = await step.custom('custom-step', async () => {
  return {
    item_name: 'A product name',
    item_price: 100,
  };
}, {
    outputSchema: {
        type: 'object',
        properties: {
            item_name: { type: 'string' },
            item_price: { type: 'number' },
        },
        required: ['item_name', 'item_price'],
    }
});
```

### Output Schema Definition

This JSON Schema definition is used to validate the output of the custom step. If the output does not match the schema, the workflow will fail.
Novu Framework will infer the Typescript interface from the JSON Schema definition.

### Return Value

The Custom Step function should return a valid serializable object. The return value will be persisted in the durable execution context.

## Using the Custom Step Result

The result can only be used in the `resolver` of the step/providers/skip functions of subsequent steps.

```typescript theme={null}
workflow('hello-world-workflow', async ({ payload }) => {
    const task = await step.custom('fetch-db-data', async () => {
        const taskData = db.fetchTask(payload.task_id);
        return {
            task_id: taskData.id,
            task_title: taskData.title,
            complete: taskData.complete,
        };
    }, {
        outputSchema: {
            type: 'object',
            properties: {
                task_title: { type: 'string' },
                task_id: { type: 'string' },
                complete: { type: 'boolean' },
            },
            required: ['task_id', 'complete'],
        }
    });

    await step.email('send-email', () => {
        return {
            subject: `Task reminder for ${task.task_title}`,
            body: 'Task is not yet complete. Please complete the task.'
        }
    }, {
        // Only send the reminder E-mail if the task is not complete
        skip: () => !task.complete
    })
});



```


# Delay Action Step
Source: https://v0.x-docs.novu.co/framework/steps/delay



Use the delay action whenever you need to pause the execution of your workflow for a period of time.

```tsx theme={null}
await step.delay('delay-1-week', async () => {
  return {
	  unit: 'weeks', // 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
	  amount: 1, // the number of units to delay workflow execution for
	};
});
```


# Digest Action Step
Source: https://v0.x-docs.novu.co/framework/steps/digest



The digest engine is designed to streamline notifications by accumulating multiple trigger events into one coherent message before delivery to the subscriber.

This function proves beneficial when a user needs to be alerted about numerous triggers, but it's important to minimize the frequency of notifications. Novu automates this process, batching incoming trigger events according to a unique subscriberId. There is also the option to include a digestKey, providing additional control over event digestion workflows.

## Step Interface

```tsx theme={null}
const digestResult = await step.digest('digest-3-days', async () => {
  return {
	  unit: 'days', // 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
	  amount: 3, // the number of units to digest events for
	};
});
```

## Using the digested triggers

The digest function returns an array of triggers that have been digested.
You can use this array to perform any necessary actions on the digested triggers. Like Sending and email, or updating a database.

```tsx theme={null}
const digestResult = await step.digest('digest-3-days', async () => {
  return {
	  unit: 'days', // 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
	  amount: 3, // the number of units to digest events for
	};
});

await step.email('send-email', async () => {
  return {
    subject: 'Digest Email',
    body: `You have ${digestResult.events.length} new events`,
 };
});
```

The digest step returns an object with `events` array. Each event in the array has the following properties:

* `id` - The `job id` of the digested event
* `time` - The time when the event was triggered
* `payload` - The original payload passed to the event


# Email Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/email



E-mail expected to be an object with the following properties:

* `subject` - The subject of the email
* `body` - The HTML body of the email

Any content generation framework like [React Email](/framework/integrations/react-email) can be used here to generate the HTML Content.

```tsx theme={null}
await step.email('send-email', async (inputs) => {
  return {
    subject: 'You received a post',
    body: `<html><body>A new post has been created</body></html>`,
  };
});
```


# In-App Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/in-app



Novu offers notification center component that can be easily embedded into your application. Read more about it [here](/notification-center/introduction).

```tsx theme={null}
await step.inApp('send-in-app', async (inputs) => {
  return {
    body: `A new post has been created`,
  };
});
```


# Workflow Steps
Source: https://v0.x-docs.novu.co/framework/steps/introduction

Steps control the execution flow of your workflow, whilst Novu provides the context of your notification delivery events back into the Workflow execution context.

## Supported Steps

Novu Supports Channel and Action steps to be used as part of the workflow execution.

### Channel Steps

* [E-mail](/framework/steps/email)
* [Chat](/framework/steps/chat)
* [SMS](/framework/steps/sms)
* [Push](/framework/steps/push)
* [In-App](/framework/steps/in-app)

### Action steps

* [Delay](/framework/steps/delay)
* [Digest](/framework/steps/digest)

## Channel Steps Interface

Channel steps are used to send notifications to your Subscribers. Each channel can optionally configure the provider to customize content, enabling you to create enhanced content aligned with the specification of the provider. For example, you might like to use Slack blocks to send your Chat message.

All channels follow the same interface:

```tsx theme={null}
await step.email('new-post', async (inputs) => {
    return {
        subject: 'You received a post',
        body: `<html><body>A new post has been created</body></html>`,
    }
}, options);
```

* `new-post` is the unique to the workflow identifier for this step. You cannot have 2 steps using the same identifier
* `resolver` function, used to return the content of the channel.
* `options` this is an optional configuration object that defines: [Input Schema](/framework/concepts/inputs), [Provider Overrides](#provider-overrides), skip and other configurations...

## Provider Overrides

Provider overrides are used to customize the content of the notification for a specific provider. For example, you might like to use Slack blocks to send your Chat message.

Those overrides are mapped directly to the provider specific SDKs, so you can use the same properties and methods that you would use in the provider SDK.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
}, {
    providers: {
        slack: ({ inputs }) => ({
            text: 'A new post has been created',
            blocks: [
                {
                    type: 'section',
                    text: {
                        type: 'mrkdwn',
                        text: 'A new post has been created',
                    },
                },
            ],
        }),
    }
});
```

<Info>
  Currently we only support `Slack` provider overrides. We are working on adding more providers.
</Info>

When overriding a provider specific behavior, Novu still requires the default content to be returned from the resolver function.
This is because the default content is used for the fallback provider, or when the provider override is not available.

## Skip Step

A step can be conditionally skipped by returning `true` from the resolver function. This is helpful when you want to use your existing user-preference system instead of Novu.
Or conditionally skip a step if it's not relevant any more for delivery.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
}, {
    skip: () => true,
});
```


# Push Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/push



```tsx theme={null}
await step.push('send-push', async () => {
  return {
    subject: 'You received a post',
    body: 'A new post has been created',
  };
});
```


# SMS Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/sms



```tsx theme={null}
await step.sms('send-sms', async () => {
  return {
    body: 'A new post has been created',
  };
});
```


# Angular Component Library
Source: https://v0.x-docs.novu.co/sdks/angular

Novu’s Angular library provides an Angular component wrapper over the Notification Center Web that you can use to integrate the notification center into your Angular application. 

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/notification-center-angular)

## Installation

```javascript theme={null}
npm install @novu/notification-center-angular
```

<Tip> If you're ready to start integrating in your Angular app, jump straight to our [Angular quickstart](/quickstarts/angular)</Tip>

Learn more about usage of the [Angular Component in detail.](/notification-center/client/angular)


# Headless JavaScript Service
Source: https://v0.x-docs.novu.co/sdks/headless-javascript-service

Novu’s headless library provides users with a lightweight, completely unstyled, zero UI solution for integrating notification functionality into their web applications.

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/headless)

With just the essential API methods, users can easily incorporate our notification system into any framework or vanilla JavaScript project, without being constrained by our default UI or dependencies.

<Tip>
  If you're ready to start using the Headless Notification Center, check out our [guide!](/guides/headless-notification-center-guide)
</Tip>

Learn more about usage of the [Headless Services in detail.](/notification-center/client/headless/get-started)


# Iframe Embed Notification Center
Source: https://v0.x-docs.novu.co/sdks/iframe-embed

Embed a real-time notification center inside an iframe using our embedded script.

If you are using a (currently) unsupported client framework, you can use our embedded script.

Learn more about usage of the [Iframe Embed in detail.](/notification-center/client/iframe)


# SDKs & Client Libraries
Source: https://v0.x-docs.novu.co/sdks/introduction

You can interface with Novu's API either over REST, or via libraries for certain languages. Below is a list of our official, supported libraries.

<Note>It's important to note that our API and backend SDK are intended for use exclusively in server-side applications.
**Attempting to use them in a client-side application will result in Cross-Origin Resource Sharing (CORS) errors.**
This restriction ensures the security and integrity of our services.</Note>

## Client Side

The Client side libraries and components helps to add a fully functional notification center to your application.

<CardGroup>
  <Card title="Vue" icon="vuejs" href="/sdks/vue">
    Embed a real-time notification center component in your Vue application.
  </Card>

  <Card title="React" icon="react" href="/sdks/react">
    Embed a real-time notification center component in your React application.
  </Card>

  <Card title="Angular" icon="angular" href="/sdks/angular">
    Embed a real-time notification center component in your Angular application.
  </Card>

  <Card title="Web Component" icon="square-js" href="/sdks/web-component">
    Embed a real-time notification center component in your JavaScript
    application.
  </Card>

  <Card title="IFrame Embed" icon="html5" href="/sdks/iframe-embed">
    Embed a real-time notification center inside an iframe using our embedded
    script.
  </Card>

  <Card title="Headless JavaScript" icon="js" href="/sdks/headless-javascript-service">
    Embed a notification system into any framework or vanilla JavaScript
    project, without being constrained by our default UI or dependencies.
  </Card>
</CardGroup>

## Server Side

The Server side libraries helps to trigger notifications and interact with all of Novu’s API seamlessly.

<CardGroup>
  <Card
    title="Node.js"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="21.47" viewBox="0 0 512 314"><defs><linearGradient id="logosNodejs0" x1="68.188%" x2="27.823%" y1="17.487%" y2="89.755%"><stop offset="0%" stopColor="#41873F"/><stop offset="32.88%" stopColor="#418B3D"/><stop offset="63.52%" stopColor="#419637"/><stop offset="93.19%" stopColor="#3FA92D"/><stop offset="100%" stopColor="#3FAE2A"/></linearGradient><linearGradient id="logosNodejs1" x1="43.277%" x2="159.245%" y1="55.169%" y2="-18.306%"><stop offset="13.76%" stopColor="#41873F"/><stop offset="40.32%" stopColor="#54A044"/><stop offset="71.36%" stopColor="#66B848"/><stop offset="90.81%" stopColor="#6CC04A"/></linearGradient><linearGradient id="logosNodejs2" x1="-4413.77%" x2="5327.93%" y1="13.43%" y2="13.43%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs3" x1="-4.389%" x2="101.499%" y1="49.997%" y2="49.997%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs4" x1="-9713.77%" x2="27.93%" y1="36.21%" y2="36.21%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs5" x1="-103.861%" x2="100.797%" y1="50.275%" y2="50.275%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs6" x1="130.613%" x2="4.393%" y1="-211.069%" y2="201.605%"><stop offset="0%" stopColor="#41873F"/><stop offset="32.88%" stopColor="#418B3D"/><stop offset="63.52%" stopColor="#419637"/><stop offset="93.19%" stopColor="#3FA92D"/><stop offset="100%" stopColor="#3FAE2A"/></linearGradient><path id="logosNodejs7" d="M57.903 1.85a5.957 5.957 0 0 0-5.894 0L3.352 29.933c-1.85 1.04-2.89 3.005-2.89 5.085v56.286c0 2.08 1.156 4.045 2.89 5.085l48.657 28.085a5.957 5.957 0 0 0 5.894 0l48.658-28.085c1.849-1.04 2.89-3.005 2.89-5.085V35.019c0-2.08-1.157-4.045-2.89-5.085L57.903 1.85Z"/></defs><g fill="none"><path fill="#539E43" d="M253.11 313.094c-1.733 0-3.351-.462-4.854-1.271l-15.371-9.13c-2.312-1.272-1.156-1.734-.462-1.965c3.12-1.04 3.698-1.272 6.934-3.12c.347-.232.81-.116 1.156.115l11.789 7.05c.462.231 1.04.231 1.386 0l46.115-26.698c.462-.231.694-.694.694-1.271v-53.28c0-.579-.232-1.04-.694-1.272l-46.115-26.582c-.462-.232-1.04-.232-1.386 0l-46.115 26.582c-.462.231-.694.809-.694 1.271v53.28c0 .463.232 1.04.694 1.272l12.598 7.281c6.819 3.467 11.095-.578 11.095-4.623v-52.587c0-.693.578-1.387 1.387-1.387h5.894c.694 0 1.387.578 1.387 1.387v52.587c0 9.13-4.97 14.447-13.638 14.447c-2.658 0-4.738 0-10.633-2.89l-12.135-6.934c-3.005-1.733-4.854-4.97-4.854-8.437v-53.28c0-3.467 1.849-6.704 4.854-8.437l46.114-26.698c2.89-1.618 6.82-1.618 9.709 0l46.114 26.698c3.005 1.733 4.855 4.97 4.855 8.437v53.28c0 3.467-1.85 6.704-4.855 8.437l-46.114 26.698c-1.503.694-3.236 1.04-4.854 1.04Zm14.216-36.637c-20.225 0-24.386-9.246-24.386-17.105c0-.694.578-1.387 1.387-1.387h6.01c.693 0 1.271.462 1.271 1.156c.925 6.125 3.583 9.13 15.834 9.13c9.708 0 13.87-2.196 13.87-7.397c0-3.005-1.157-5.2-16.297-6.703c-12.598-1.272-20.457-4.045-20.457-14.1c0-9.362 7.86-14.91 21.035-14.91c14.793 0 22.075 5.086 23 16.18c0 .348-.116.694-.347 1.041c-.232.231-.578.462-.925.462h-6.01c-.578 0-1.156-.462-1.271-1.04c-1.387-6.356-4.97-8.437-14.447-8.437c-10.633 0-11.905 3.699-11.905 6.472c0 3.352 1.503 4.392 15.834 6.241c14.216 1.85 20.92 4.508 20.92 14.447c-.116 10.171-8.437 15.95-23.116 15.95Z"/><path fill="#333" d="M110.028 104.712c0-2.08-1.156-4.046-3.005-5.086l-49.004-28.2c-.81-.463-1.734-.694-2.658-.81h-.463c-.924 0-1.849.347-2.658.81l-49.004 28.2c-1.85 1.04-3.005 3.005-3.005 5.086l.116 75.817c0 1.04.578 2.08 1.502 2.543c.925.578 2.08.578 2.89 0l29.125-16.643c1.849-1.04 3.005-3.005 3.005-5.085v-35.482c0-2.08 1.155-4.045 3.005-5.085l12.366-7.166c.925-.578 1.965-.81 3.005-.81c1.04 0 2.08.232 2.89.81l12.366 7.166c1.85 1.04 3.005 3.004 3.005 5.085v35.482c0 2.08 1.156 4.045 3.005 5.085l29.125 16.643a2.82 2.82 0 0 0 3.005 0c.925-.463 1.503-1.503 1.503-2.543l-.116-75.817ZM345.571.347c-.924-.463-2.08-.463-2.89 0c-.924.578-1.502 1.502-1.502 2.542v75.125c0 .693-.346 1.386-1.04 1.849c-.693.346-1.387.346-2.08 0l-12.251-7.05a5.957 5.957 0 0 0-5.895 0l-49.004 28.316c-1.849 1.04-3.005 3.005-3.005 5.085v56.516c0 2.08 1.156 4.046 3.005 5.086l49.004 28.316a5.957 5.957 0 0 0 5.895 0l49.004-28.316c1.849-1.04 3.005-3.005 3.005-5.086V21.844c0-2.196-1.156-4.16-3.005-5.201L345.572.347Zm-4.507 143.776c0 .578-.231 1.04-.694 1.271l-16.758 9.708a1.714 1.714 0 0 1-1.503 0l-16.758-9.708c-.463-.231-.694-.809-.694-1.271v-19.417c0-.578.231-1.04.694-1.271l16.758-9.709a1.714 1.714 0 0 1 1.503 0l16.758 9.709c.463.23.694.809.694 1.271v19.417Zm167.584-19.879c1.85-1.04 2.89-3.005 2.89-5.086v-13.753c0-2.08-1.156-4.045-2.89-5.085l-48.657-28.2a5.957 5.957 0 0 0-5.895 0l-49.004 28.315c-1.85 1.04-3.005 3.005-3.005 5.085v56.517c0 2.08 1.156 4.045 3.005 5.085l48.657 27.738c1.85 1.04 4.046 1.04 5.78 0L489 178.45c.925-.463 1.503-1.503 1.503-2.543c0-1.04-.578-2.08-1.503-2.543l-49.235-28.316c-.925-.578-1.503-1.502-1.503-2.542v-17.683c0-1.04.578-2.08 1.503-2.543l15.371-8.784a2.821 2.821 0 0 1 3.005 0l15.372 8.784c.925.578 1.502 1.502 1.502 2.543v13.869c0 1.04.578 2.08 1.503 2.542a2.82 2.82 0 0 0 3.005 0l29.125-16.99Z"/><path fill="#539E43" d="M456.292 121.585a1.05 1.05 0 0 1 1.156 0l9.362 5.432c.346.232.577.578.577 1.04v10.865c0 .462-.23.809-.577 1.04l-9.362 5.432a1.05 1.05 0 0 1-1.156 0l-9.361-5.432c-.347-.231-.578-.578-.578-1.04v-10.864c0-.463.23-.81.578-1.04l9.361-5.433Z"/><g transform="translate(134.068 70.501)"><mask id="logosNodejs8" fill="#fff"><use href="#logosNodejs7"/></mask><use fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs0)" href="#logosNodejs7"/><g mask="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs8)"><path d="M51.893 1.85L3.121 29.933C1.27 30.974 0 32.94 0 35.02v56.286c0 1.387.578 2.658 1.502 3.698L56.285 1.156c-1.387-.231-3.005-.116-4.392.693Zm4.739 123.203c.462-.116.925-.347 1.387-.578l48.773-28.085c1.85-1.04 3.005-3.005 3.005-5.085V35.019c0-1.502-.694-3.005-1.734-4.045l-51.43 94.079Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs1)" d="M106.676 29.934L57.788 1.85a8.025 8.025 0 0 0-1.503-.578L1.502 95.12a6.082 6.082 0 0 0 1.619 1.387l48.888 28.085c1.387.809 3.005 1.04 4.507.577l51.432-94.078c-.347-.462-.81-.81-1.272-1.156Z"/></g><g mask="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs8)"><path d="M109.797 91.305V35.019c0-2.08-1.271-4.045-3.12-5.085L57.786 1.85a5.106 5.106 0 0 0-1.848-.693l53.511 91.42c.231-.347.347-.809.347-1.271ZM3.12 29.934C1.272 30.974 0 32.94 0 35.02v56.286c0 2.08 1.387 4.045 3.12 5.085l48.889 28.085c1.156.693 2.427.925 3.814.693L3.467 29.818l-.346.116Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs2)" fillRule="evenodd" d="m50.391.809l-.693.347h.924l-.231-.347Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs3)" fillRule="evenodd" d="M106.792 105.636c1.387-.809 2.427-2.196 2.89-3.698L56.053 10.402c-1.387-.231-2.89-.116-4.16.693L3.351 39.065l52.355 95.465a8.057 8.057 0 0 0 2.196-.693l48.889-28.2Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs4)" fillRule="evenodd" d="m111.3 104.712l-.347-.578v.809l.346-.231Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs5)" fillRule="evenodd" d="m106.792 105.636l-48.773 28.085a6.973 6.973 0 0 1-2.196.693l.925 1.734l54.089-31.32v-.694l-1.387-2.312c-.231 1.618-1.271 3.005-2.658 3.814Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs6)" fillRule="evenodd" d="m106.792 105.636l-48.773 28.085a6.973 6.973 0 0 1-2.196.693l.925 1.734l54.089-31.32v-.694l-1.387-2.312c-.231 1.618-1.271 3.005-2.658 3.814Z" transform="translate(0 -9.246)"/></g></g></g></svg>
}
    href="/sdks/nodejs"
  >
    Connect your Node app to Novu via the Node.js SDK.
  </Card>

  <Card
    title="PHP"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#deviconPhp0)" d="M0 64c0 18.593 28.654 33.667 64 33.667c35.346 0 64-15.074 64-33.667c0-18.593-28.655-33.667-64-33.667C28.654 30.333 0 45.407 0 64Z"/><path fill="#777bb3" d="M64 95.167c33.965 0 61.5-13.955 61.5-31.167c0-17.214-27.535-31.167-61.5-31.167S2.5 46.786 2.5 64c0 17.212 27.535 31.167 61.5 31.167Z"/><path d="M34.772 67.864c2.793 0 4.877-.515 6.196-1.53c1.306-1.006 2.207-2.747 2.68-5.175c.44-2.27.272-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.464l-2.473 12.732zM20.173 83.547a.694.694 0 0 1-.68-.828l6.557-33.738a.695.695 0 0 1 .68-.561h14.134c4.442 0 7.748 1.206 9.827 3.585c2.088 2.39 2.734 5.734 1.917 9.935c-.333 1.711-.905 3.3-1.7 4.724a15.818 15.818 0 0 1-3.128 3.92c-1.531 1.432-3.264 2.472-5.147 3.083c-1.852.604-4.232.91-7.07.91h-5.724l-1.634 8.408a.695.695 0 0 1-.682.562z"/><path fill="#fff" d="M34.19 55.826h3.891c3.107 0 4.186.682 4.553 1.089c.607.674.723 2.097.331 4.112c-.439 2.257-1.253 3.858-2.42 4.756c-1.194.92-3.138 1.386-5.773 1.386h-2.786l2.205-11.342zm6.674-8.1H26.731a1.39 1.39 0 0 0-1.364 1.123L18.81 82.588a1.39 1.39 0 0 0 1.363 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.151c2.912 0 5.364-.318 7.287-.944c1.977-.642 3.796-1.731 5.406-3.237a16.522 16.522 0 0 0 3.259-4.087c.831-1.487 1.429-3.147 1.775-4.931c.86-4.423.161-7.964-2.076-10.524c-2.216-2.537-5.698-3.823-10.349-3.823zM30.301 68.557h4.471c2.963 0 5.17-.557 6.62-1.675c1.451-1.116 2.428-2.98 2.938-5.591c.485-2.508.264-4.277-.665-5.308c-.931-1.03-2.791-1.546-5.584-1.546h-5.036l-2.743 14.12m10.563-19.445c4.252 0 7.353 1.117 9.303 3.348c1.95 2.232 2.536 5.347 1.76 9.346c-.322 1.648-.863 3.154-1.625 4.518c-.764 1.366-1.76 2.614-2.991 3.747c-1.468 1.373-3.097 2.352-4.892 2.935c-1.794.584-4.08.875-6.857.875h-6.296l-1.743 8.97h-7.35l6.558-33.739h14.133"/><path d="M69.459 74.577a.694.694 0 0 1-.682-.827l2.9-14.928c.277-1.42.209-2.438-.19-2.87c-.245-.263-.979-.704-3.15-.704h-5.256l-3.646 18.768a.695.695 0 0 1-.683.56h-7.29a.695.695 0 0 1-.683-.826l6.558-33.739a.695.695 0 0 1 .682-.561h7.29a.695.695 0 0 1 .683.826L64.41 48.42h5.653c4.307 0 7.227.758 8.928 2.321c1.733 1.593 2.275 4.14 1.608 7.573l-3.051 15.702a.695.695 0 0 1-.682.56h-7.407z"/><path fill="#fff" d="M65.31 38.755h-7.291a1.39 1.39 0 0 0-1.364 1.124l-6.557 33.738a1.39 1.39 0 0 0 1.363 1.654h7.291a1.39 1.39 0 0 0 1.364-1.124l3.537-18.205h4.682c2.168 0 2.624.463 2.641.484c.132.14.305.795.019 2.264l-2.9 14.927a1.39 1.39 0 0 0 1.364 1.654h7.408a1.39 1.39 0 0 0 1.363-1.124l3.051-15.7c.715-3.686.103-6.45-1.82-8.217c-1.836-1.686-4.91-2.505-9.398-2.505h-4.81l1.421-7.315a1.39 1.39 0 0 0-1.364-1.655zm0 1.39l-1.743 8.968h6.496c4.087 0 6.907.714 8.457 2.14c1.553 1.426 2.017 3.735 1.398 6.93l-3.052 15.699h-7.407l2.901-14.928c.33-1.698.208-2.856-.365-3.474c-.573-.617-1.793-.926-3.658-.926h-5.829l-3.756 19.327H51.46l6.558-33.739h7.292z"/><path d="M92.136 67.864c2.793 0 4.878-.515 6.198-1.53c1.304-1.006 2.206-2.747 2.679-5.175c.44-2.27.273-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.463l-2.475 12.732zM77.54 83.547a.694.694 0 0 1-.682-.828l6.557-33.738a.695.695 0 0 1 .682-.561H98.23c4.442 0 7.748 1.206 9.826 3.585c2.089 2.39 2.734 5.734 1.917 9.935a15.878 15.878 0 0 1-1.699 4.724a15.838 15.838 0 0 1-3.128 3.92c-1.53 1.432-3.265 2.472-5.147 3.083c-1.852.604-4.232.91-7.071.91h-5.723l-1.633 8.408a.695.695 0 0 1-.683.562z"/><path fill="#fff" d="M91.555 55.826h3.891c3.107 0 4.186.682 4.552 1.089c.61.674.724 2.097.333 4.112c-.44 2.257-1.254 3.858-2.421 4.756c-1.195.92-3.139 1.386-5.773 1.386h-2.786l2.204-11.342zm6.674-8.1H84.096a1.39 1.39 0 0 0-1.363 1.123l-6.558 33.739a1.39 1.39 0 0 0 1.364 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.15c2.911 0 5.364-.318 7.286-.944c1.978-.642 3.797-1.731 5.408-3.238a16.52 16.52 0 0 0 3.258-4.086c.832-1.487 1.428-3.147 1.775-4.931c.86-4.423.162-7.964-2.076-10.524c-2.216-2.537-5.697-3.823-10.35-3.823zM87.666 68.557h4.47c2.964 0 5.17-.557 6.622-1.675c1.45-1.116 2.428-2.98 2.936-5.591c.487-2.508.266-4.277-.665-5.308c-.93-1.03-2.791-1.546-5.583-1.546h-5.035Zm10.563-19.445c4.251 0 7.354 1.117 9.303 3.348c1.95 2.232 2.537 5.347 1.759 9.346c-.32 1.648-.862 3.154-1.624 4.518c-.763 1.366-1.76 2.614-2.992 3.747c-1.467 1.373-3.097 2.352-4.892 2.935c-1.793.584-4.078.875-6.856.875h-6.295l-1.745 8.97h-7.35l6.558-33.739h14.133"/><defs><radialGradient id="deviconPhp0" cx="0" cy="0" r="1" gradientTransform="translate(38.426 42.169) scale(84.04136)" gradientUnits="userSpaceOnUse"><stop stopColor="#AEB2D5"/><stop offset=".3" stopColor="#AEB2D5"/><stop offset=".75" stopColor="#484C89"/><stop offset="1" stopColor="#484C89"/></radialGradient></defs></svg>
}
    href="/sdks/php"
  >
    Connect your PHP app to Novu via the PHP SDK.
  </Card>

  <Card title="Laravel" icon="laravel" href="/sdks/laravel">
    Connect your Laravel app to Novu via the Laravel SDK.
  </Card>

  <Card
    title="Python"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="34.87" viewBox="0 0 256 255"><defs><linearGradient id="logosPython0" x1="12.959%" x2="79.639%" y1="12.039%" y2="78.201%"><stop offset="0%" stopColor="#387EB8"/><stop offset="100%" stopColor="#366994"/></linearGradient><linearGradient id="logosPython1" x1="19.128%" x2="90.742%" y1="20.579%" y2="88.429%"><stop offset="0%" stopColor="#FFE052"/><stop offset="100%" stopColor="#FFC331"/></linearGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosPython0)" d="M126.916.072c-64.832 0-60.784 28.115-60.784 28.115l.072 29.128h61.868v8.745H41.631S.145 61.355.145 126.77c0 65.417 36.21 63.097 36.21 63.097h21.61v-30.356s-1.165-36.21 35.632-36.21h61.362s34.475.557 34.475-33.319V33.97S194.67.072 126.916.072ZM92.802 19.66a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.13Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosPython1)" d="M128.757 254.126c64.832 0 60.784-28.115 60.784-28.115l-.072-29.127H127.6v-8.745h86.441s41.486 4.705 41.486-60.712c0-65.416-36.21-63.096-36.21-63.096h-21.61v30.355s1.165 36.21-35.632 36.21h-61.362s-34.475-.557-34.475 33.32v56.013s-5.235 33.897 62.518 33.897Zm34.114-19.586a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.131a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13Z"/></svg>
}
    href="/sdks/python"
  >
    Connect your Python app to Novu via the Python SDK.
  </Card>

  <Card
    title="Kotlin"
    icon={
<svg
    xmlns="http://www.w3.org/2000/svg"
    width="20"
    height="20"
    viewBox="0 0 256 256"
  >
    <defs>
      <linearGradient
        id="logosKotlinIcon0"
        x1="99.991%"
        x2=".01%"
        y1="-.011%"
        y2="100.01%"
      >
        <stop offset=".344%" stopColor="#E44857" />
        <stop offset="46.89%" stopColor="#C711E1" />
        <stop offset="100%" stopColor="#7F52FF" />
      </linearGradient>
    </defs>
    <path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosKotlinIcon0)" d="M256 256H0V0h256L128 127.949z" />
  </svg>}
    href="/quickstarts/kotlin"
  >
    Connect your Kotlin app to Novu via the Kotlin SDK.
  </Card>

  <Card
    title="Java"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="#0074BD" d="M47.617 98.12s-4.767 2.774 3.397 3.71c9.892 1.13 14.947.968 25.845-1.092c0 0 2.871 1.795 6.873 3.351c-24.439 10.47-55.308-.607-36.115-5.969zm-2.988-13.665s-5.348 3.959 2.823 4.805c10.567 1.091 18.91 1.18 33.354-1.6c0 0 1.993 2.025 5.132 3.131c-29.542 8.64-62.446.68-41.309-6.336z"/><path fill="#EA2D2E" d="M69.802 61.271c6.025 6.935-1.58 13.17-1.58 13.17s15.289-7.891 8.269-17.777c-6.559-9.215-11.587-13.792 15.635-29.58c0 .001-42.731 10.67-22.324 34.187z"/><path fill="#0074BD" d="M102.123 108.229s3.529 2.91-3.888 5.159c-14.102 4.272-58.706 5.56-71.094.171c-4.451-1.938 3.899-4.625 6.526-5.192c2.739-.593 4.303-.485 4.303-.485c-4.953-3.487-32.013 6.85-13.743 9.815c49.821 8.076 90.817-3.637 77.896-9.468zM49.912 70.294s-22.686 5.389-8.033 7.348c6.188.828 18.518.638 30.011-.326c9.39-.789 18.813-2.474 18.813-2.474s-3.308 1.419-5.704 3.053c-23.042 6.061-67.544 3.238-54.731-2.958c10.832-5.239 19.644-4.643 19.644-4.643zm40.697 22.747c23.421-12.167 12.591-23.86 5.032-22.285c-1.848.385-2.677.72-2.677.72s.688-1.079 2-1.543c14.953-5.255 26.451 15.503-4.823 23.725c0-.002.359-.327.468-.617z"/><path fill="#EA2D2E" d="M76.491 1.587S89.459 14.563 64.188 34.51c-20.266 16.006-4.621 25.13-.007 35.559c-11.831-10.673-20.509-20.07-14.688-28.815C58.041 28.42 81.722 22.195 76.491 1.587z"/><path fill="#0074BD" d="M52.214 126.021c22.476 1.437 57-.8 57.817-11.436c0 0-1.571 4.032-18.577 7.231c-19.186 3.612-42.854 3.191-56.887.874c0 .001 2.875 2.381 17.647 3.331z"/></svg>
}
    href="/sdks/java"
  >
    Connect your Java app to Novu via the Java SDK.
  </Card>

  <Card
    title="Ruby"
    icon={<svg xmlns="http://www.w3.org/2000/svg" width="20" height="19.93" viewBox="0 0 256 255"><defs><linearGradient id="logosRuby0" x1="84.75%" x2="58.254%" y1="111.399%" y2="64.584%"><stop offset="0%" stopColor="#FB7655"/><stop offset="0%" stopColor="#FB7655"/><stop offset="41%" stopColor="#E42B1E"/><stop offset="99%" stopColor="#900"/><stop offset="100%" stopColor="#900"/></linearGradient><linearGradient id="logosRuby1" x1="116.651%" x2="1.746%" y1="60.89%" y2="19.288%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby2" x1="75.774%" x2="38.978%" y1="219.327%" y2="7.829%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby3" x1="50.012%" x2="66.483%" y1="7.234%" y2="79.135%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E57252"/><stop offset="46%" stopColor="#DE3B20"/><stop offset="99%" stopColor="#A60003"/><stop offset="100%" stopColor="#A60003"/></linearGradient><linearGradient id="logosRuby4" x1="46.174%" x2="49.932%" y1="16.348%" y2="83.047%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E4714E"/><stop offset="56%" stopColor="#BE1A0D"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby5" x1="36.965%" x2="49.528%" y1="15.594%" y2="92.478%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="18%" stopColor="#E46342"/><stop offset="40%" stopColor="#C82410"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby6" x1="13.609%" x2="85.764%" y1="58.346%" y2="-46.717%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="54%" stopColor="#C81F11"/><stop offset="99%" stopColor="#BF0905"/><stop offset="100%" stopColor="#BF0905"/></linearGradient><linearGradient id="logosRuby7" x1="27.624%" x2="50.745%" y1="21.135%" y2="79.056%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="31%" stopColor="#DE4024"/><stop offset="99%" stopColor="#BF190B"/><stop offset="100%" stopColor="#BF190B"/></linearGradient><linearGradient id="logosRuby8" x1="-20.667%" x2="104.242%" y1="122.282%" y2="-6.342%"><stop offset="0%" stopColor="#BD0012"/><stop offset="0%" stopColor="#BD0012"/><stop offset="7%" stopColor="#FFF"/><stop offset="17%" stopColor="#FFF"/><stop offset="27%" stopColor="#C82F1C"/><stop offset="33%" stopColor="#820C01"/><stop offset="46%" stopColor="#A31601"/><stop offset="72%" stopColor="#B31301"/><stop offset="99%" stopColor="#E82609"/><stop offset="100%" stopColor="#E82609"/></linearGradient><linearGradient id="logosRuby9" x1="58.792%" x2="11.964%" y1="65.205%" y2="50.128%"><stop offset="0%" stopColor="#8C0C01"/><stop offset="0%" stopColor="#8C0C01"/><stop offset="54%" stopColor="#990C00"/><stop offset="99%" stopColor="#A80D0E"/><stop offset="100%" stopColor="#A80D0E"/></linearGradient><linearGradient id="logosRubya" x1="79.319%" x2="23.088%" y1="62.754%" y2="17.888%"><stop offset="0%" stopColor="#7E110B"/><stop offset="0%" stopColor="#7E110B"/><stop offset="99%" stopColor="#9E0C00"/><stop offset="100%" stopColor="#9E0C00"/></linearGradient><linearGradient id="logosRubyb" x1="92.88%" x2="59.841%" y1="74.122%" y2="39.704%"><stop offset="0%" stopColor="#79130D"/><stop offset="0%" stopColor="#79130D"/><stop offset="99%" stopColor="#9E120B"/><stop offset="100%" stopColor="#9E120B"/></linearGradient><linearGradient id="logosRubyc" x1="56.57%" x2="3.105%" y1="101.717%" y2="11.993%"><stop offset="0%" stopColor="#8B2114"/><stop offset="0%" stopColor="#8B2114"/><stop offset="43%" stopColor="#9E100A"/><stop offset="99%" stopColor="#B3100C"/><stop offset="100%" stopColor="#B3100C"/></linearGradient><linearGradient id="logosRubyd" x1="30.87%" x2="92.471%" y1="35.599%" y2="100.694%"><stop offset="0%" stopColor="#B31000"/><stop offset="0%" stopColor="#B31000"/><stop offset="44%" stopColor="#910F08"/><stop offset="99%" stopColor="#791C12"/><stop offset="100%" stopColor="#791C12"/></linearGradient><radialGradient id="logosRubye" cx="32.001%" cy="40.21%" r="69.573%" fx="32.001%" fy="40.21%"><stop offset="0%" stopColor="#A80D00"/><stop offset="0%" stopColor="#A80D00"/><stop offset="99%" stopColor="#7E0E08"/><stop offset="100%" stopColor="#7E0E08"/></radialGradient><radialGradient id="logosRubyf" cx="13.549%" cy="40.86%" r="88.386%" fx="13.549%" fy="40.86%"><stop offset="0%" stopColor="#A30C00"/><stop offset="0%" stopColor="#A30C00"/><stop offset="99%" stopColor="#800E08"/><stop offset="100%" stopColor="#800E08"/></radialGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby0)" d="m197.467 167.764l-145.52 86.41l188.422-12.787L254.88 51.393l-57.414 116.37Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby1)" d="M240.677 241.257L224.482 129.48l-44.113 58.25l60.308 53.528Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby2)" d="m240.896 241.257l-118.646-9.313l-69.674 21.986l188.32-12.673Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby3)" d="m52.744 253.955l29.64-97.1L17.16 170.8l35.583 83.154Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby4)" d="M180.358 188.05L153.085 81.226l-78.047 73.16l105.32 33.666Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby5)" d="m248.693 82.73l-73.777-60.256l-20.544 66.418l94.321-6.162Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby6)" d="M214.191.99L170.8 24.97L143.424.669l70.767.322Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby7)" d="m0 203.372l18.177-33.151l-14.704-39.494L0 203.372Z"/><path fill="#FFF" d="m2.496 129.48l14.794 41.963l64.283-14.422l73.39-68.207l20.712-65.787L143.063 0L87.618 20.75c-17.469 16.248-51.366 48.396-52.588 49c-1.21.618-22.384 40.639-32.534 59.73Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby8)" d="M54.442 54.094c37.86-37.538 86.667-59.716 105.397-40.818c18.72 18.898-1.132 64.823-38.992 102.349c-37.86 37.525-86.062 60.925-104.78 42.027c-18.73-18.885.515-66.032 38.375-103.558Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby9)" d="m52.744 253.916l29.408-97.409l97.665 31.376c-35.312 33.113-74.587 61.106-127.073 66.033Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubya)" d="m155.092 88.622l25.073 99.313c29.498-31.016 55.972-64.36 68.938-105.603l-94.01 6.29Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubyb)" d="M248.847 82.833c10.035-30.282 12.35-73.725-34.966-81.791l-38.825 21.445l73.791 60.346Z"/><path fill="#9E1209" d="M0 202.935c1.39 49.979 37.448 50.724 52.808 51.162l-35.48-82.86L0 202.935Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubye)" d="M155.232 88.777c22.667 13.932 68.35 41.912 69.276 42.426c1.44.81 19.695-30.784 23.838-48.64l-93.114 6.214Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubyf)" d="m82.113 156.507l39.313 75.848c23.246-12.607 41.45-27.967 58.121-44.42l-97.434-31.428Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubyc)" d="m17.174 171.34l-5.57 66.328c10.51 14.357 24.97 15.605 40.136 14.486c-10.973-27.311-32.894-81.92-34.566-80.814Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubyd)" d="m174.826 22.654l78.1 10.96c-4.169-17.662-16.969-29.06-38.787-32.623l-39.313 21.663Z"/></svg>

}
    href="/quickstarts/ruby"
  >
    Connect your Ruby app to Novu via the Ruby SDK.
  </Card>

  <Card
    title="Go"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="13.13" viewBox="0 0 512 192"><path fill="#00ACD7" d="m292.533 13.295l1.124.75c13.212 8.725 22.685 20.691 28.917 35.15c1.496 2.243.499 3.49-2.493 4.237l-5.063 1.296c-11.447 2.949-20.53 5.429-31.827 8.378l-6.443 1.678c-2.32.574-2.96.333-5.428-2.477l-.348-.399c-3.519-3.988-6.155-6.652-10.817-9.03l-.899-.443c-15.705-7.727-30.911-5.484-45.12 3.74c-16.952 10.968-25.677 27.172-25.428 47.364c.25 19.942 13.96 36.395 33.654 39.137c16.951 2.244 31.16-3.739 42.378-16.452c2.244-2.743 4.238-5.734 6.73-9.224h-48.11c-5.235 0-6.481-3.24-4.736-7.478l.864-2.035c3.204-7.454 8.173-18.168 11.4-24.294l.704-1.319c.862-1.494 2.612-3.513 5.977-3.513h80.224c3.603-11.415 9.449-22.201 17.246-32.407c18.198-23.931 40.135-36.396 69.8-41.63c25.427-4.488 49.359-1.995 71.046 12.713c19.694 13.461 31.909 31.66 35.15 55.59c4.237 33.654-5.485 61.075-28.668 84.508c-16.453 16.702-36.645 27.172-59.829 31.908c-6.73 1.247-13.461 1.496-19.942 2.244c-22.685-.499-43.376-6.98-60.826-21.937c-12.273-10.61-20.727-23.648-24.928-38.828a104.937 104.937 0 0 1-10.47 16.89c-17.949 23.683-41.381 38.39-71.046 42.38c-24.43 3.24-47.115-1.497-67.058-16.454c-18.447-13.96-28.917-32.407-31.66-55.34c-3.24-27.173 4.737-51.603 21.19-73.041c17.7-23.184 41.132-37.891 69.8-43.126c22.999-4.16 45.037-1.595 64.936 11.464ZM411.12 49.017l-.798.178c-23.183 5.235-38.14 19.942-43.624 43.375c-4.488 19.444 4.985 39.138 22.934 47.115c13.71 5.983 27.421 5.235 40.633-1.496c19.694-10.22 30.413-26.175 31.66-47.613c-.25-3.24-.25-5.734-.749-8.227c-4.436-24.401-26.664-38.324-50.056-33.332ZM116.416 94.564c.997 0 1.496.748 1.496 1.745l-.499 5.983c0 .997-.997 1.745-1.745 1.745l-54.344-.249c-.997 0-1.246-.748-.748-1.496l3.49-6.232c.499-.748 1.496-1.496 2.493-1.496h49.857ZM121.9 71.63c.997 0 1.496.748 1.247 1.496l-1.995 5.983c-.249.997-1.246 1.495-2.243 1.495l-117.912.25c-.997 0-1.246-.499-.748-1.247l5.235-6.73c.499-.748 1.745-1.247 2.742-1.247H121.9Zm12.963-22.934c.997 0 1.246.748.748 1.496l-4.238 6.481c-.499.748-1.745 1.496-2.493 1.496l-90.24-.25c-.998 0-1.247-.498-.749-1.246l5.235-6.73c.499-.748 1.745-1.247 2.742-1.247h88.995Z"/></svg>
}
    href="/sdks/go"
  >
    Connect your Golang app to Novu via the Go SDK.
  </Card>

  <Card
    title=".NET"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 256 256"><g fill="none"><rect width="256" height="256" fill="#512BD4" rx="60"/><path fill="#fff" d="M24.052 168.943c-2.236 0-4.138-.731-5.703-2.194c-1.566-1.501-2.349-3.283-2.349-5.347c0-2.101.783-3.902 2.349-5.403c1.565-1.5 3.466-2.251 5.703-2.251c2.274 0 4.194.751 5.76 2.251c1.603 1.501 2.404 3.302 2.404 5.403c0 2.064-.801 3.846-2.404 5.347c-1.566 1.463-3.486 2.194-5.76 2.194Zm89.415-1.238H98.929l-38.304-59.318a26.371 26.371 0 0 1-2.404-4.672h-.336c.298 1.726.447 5.422.447 11.087v52.903H45.471V87H60.96l37.018 57.912c1.566 2.402 2.572 4.052 3.02 4.953h.223c-.372-2.139-.559-5.759-.559-10.863V87h12.805v80.705Zm62.631 0h-45.014V87h43.225v11.369h-29.916v22.849h27.568v11.312h-27.568v23.863h31.705v11.312Zm63.973-69.336h-23.038v69.336h-13.309V98.369h-22.982V87h59.329v11.369Z"/></g></svg>
}
    href="/sdks/dotnet"
  >
    Connect your C#/.NET app to Novu via the .NET SDK.
  </Card>
</CardGroup>


# NodeJS SDK
Source: https://v0.x-docs.novu.co/sdks/nodejs

Connect a Node.js application to Novu

Novu's Node.js SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Node.js application.

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/node)

## Installation

```javascript theme={null}
npm install @novu/node 
```

<Tip> If you're ready to start integrating in your Node.js app, jump straight to our [Nodejs quickstart.](/quickstarts/nodejs)</Tip>

## Usage

```javascript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<USER_IDENTIFIER>',
    email: 'test@email.com',
    firstName: 'John',
    lastName: 'Doe',
  },
  payload: {
    organization: {
      logo: 'https://evilcorp.com/logo.png',
    },
  },
});
```


# PHP SDK
Source: https://v0.x-docs.novu.co/sdks/php

Connect a PHP application to Novu

Novu's PHP SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your PHP application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-php)

## Installation

```php theme={null}
composer require unicodeveloper/novu
```

<Tip> If you're ready to start integrating in your PHP app, jump straight to our [PHP quickstart.](/quickstarts/php)</Tip>

## Usage

```php theme={null}
use Novu\SDK\Novu;

$novu = new Novu(<INSERT_API_KEY_HERE>);

// Sign up on https://web.novu.co and grab your API key from https://web.novu.co/settings

$response = $novu->triggerEvent([
    'name' => '<REPLACE_WITH_TEMPLATE_NAME_FROM_ADMIN_PANEL>',
    'payload' => ['customVariables' => 'Hello'],
    'to' => [
        'subscriberId' => '<SUBSCRIBER_IDENTIFIER_FROM_ADMIN_PANEL>',
        'phone' => '07983882186'
    ]
])->toArray();
```


# React Component
Source: https://v0.x-docs.novu.co/sdks/react

Novu’s React library provides a fully functional and embeddable notification center component with real-time updates that you can drop into your React application.

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/notification-center)

## Installation

```javascript theme={null}
npm install @novu/notification-center
```

<Tip> If you're ready to start integrating in your React app, jump straight to our [quickstart](/quickstarts/react)</Tip>

Learn more about usage of the [React Component in detail.](/notification-center/client/react/get-started)


# Vue library
Source: https://v0.x-docs.novu.co/sdks/vue

Novu’s Vue library provides a Vue component wrapper over the Notification Center Web that you can use to integrate the notification center into your Vue application. 

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/notification-center-vue)

## Installation

```javascript theme={null}
npm install @novu/notification-center-vue
```

<Tip> If you're ready to start integrating in your Vue app, jump straight to the [Vue quickstart.](/quickstarts/vue)</Tip>

Learn more about usage of the [Vue Component in detail.](/notification-center/client/vue)


# Web Component Library
Source: https://v0.x-docs.novu.co/sdks/web-component

Novu’s Web Component library provides a fully functional and embeddable notification center widget with real-time updates that you can drop into any web application.

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/notification-center)

## Installation

You can use the web component in two ways:

* As an ESM Module
* As a bundled CDN version

<Tip> If you're ready to start integrating in your web app, jump straight to the [Web component quickstart.](/quickstarts/vanillajs)</Tip>

Learn more about usage of the [Web Component in detail.](/notification-center/client/web-component)


# Security and Compliance
Source: https://v0.x-docs.novu.co/security-and-compliance/security

Common questions related to security, compliance, privacy policy and terms and conditions

### What should I do if I have regulatory or security issues with PII?

We regularly work with big companies and are happy to help and support you with guidance, and various compliances including reports to ease your security and legal team. If you have concerns about PII, you can use our OS version, Novu Hybrid-Cloud enterprise plan, or reach out to us at [sales@novu.co](mailto:sales@novu.co), [support@novu.co](mailto:support@novu.co), or Discord.

### I need my data to reside in the EU, can it be done?

Yes, as part of our GDPR compliance we have our cloud version available on both EU (Frankfurt), as well as US (Virginia).

### Are you GDPR compliant?

Yes, you can see the complete compliance report on our [security page](https://trust.novu.co/). Novu also decided to take the extra step and provide separate data residency in both the EU and the US.

### I created my account in the EU/US, can I switch to the other one?

Not exactly, to keep data residency intact we cannot simply copy or move data between data warehouses across US and EU. However if you have the need please contact us at [sales@novu.co](mailto:sales@novu.co)

### Are you SOC 2 compliant?

Yes, Novu Cloud is SOC 2 Type II compliant, we have made sure to do penetration tests, security training, evidence collection, and SDL. You can see live control updated on our [security page](https://trust.novu.co/), and ask for our security report as well at [sales@novu.co](mailto:sales@novu.co).

### Are you ISO 27001 compliant?

Yes, Novu Cloud is ISO27001 compliant, we have made sure to go through both Stage 1 and Stage 2 audits, and fully define ISMS requirements. From entirely creating our organization processes, defining organization risk assessment policies, and building organization Incident Response & Disaster Recovery plans.

### Where is my data stored?

Based on the selected solution there are a couple of options. On the OS option based on where you choose to store it :) As to the Novu Cloud solution, you can choose the EU (Frankfurt) or the US (Virginia). In case you are working on the Novu Hybrid-Cloud solution we will help you deploy your data inside your select network.

### For how long user data is stored?

By default, data is stored using the following TTL values

* Notifications (for 1 month)
* Jobs (for 1 month)
* Message (for in-app messages - 12 months, for all other messages - 1 month)
* Execution Details (for 1 month)
* Subscribers, Workflows, Feeds, Layouts (Not deleted automatically, can be deleted by the user at any time)

If you want to delete any specific data or information, reach out to us at [support@novu.co](mailto:support@novu.co)

### How to report any vulnerability or security issue?

We are equally committed to our users and their data’s security. We highly appreciate it if someone shares security vulnerabilities with us. Feel free to use the [github issue](https://github.com/novuhq/novu/security/advisories/new) or email us at [security@novu.co](mailto:security@novu.co).


# AWS
Source: https://v0.x-docs.novu.co/self-hosting-novu/aws

Learn how to deploy Novu to AWS

Amazon Web Services (AWS) is a cloud computing platform by Amazon, providing a wide range of on-demand services like computing power, storage, and databases over the internet.
It enables businesses and individuals to avoid managing physical infrastructure and offers features for computing, storage, databases, analytics, machine learning, and more.
AWS is known for its scalability, flexibility, and global network of data centers.
Learn more about [AWS](https://docs.aws.amazon.com/)

## Deploying on EC2 with the Docker Compose File

Deploying Novu on EC2 with Docker Compose involves several steps.

In general, the steps are as follows:

1. **Set up an EC2 Instance**: Create an instance on AWS EC2. We reccomend a bare minimum of 4 CPU Cores and 16GB of RAM.
2. **Install Docker**: Once you have your instance up and running, SSH into it and install Docker. You can do this by running the following commands:

```bash theme={null}
sudo yum update -y sudo amazon-linux-extras install docker;
sudo service docker start sudo usermod -a -G docker
ec2-user
```

3. **Install Docker Compose**: Docker Compose will allow you to easily manage your application which will consist of multiple Docker containers.
   Install it by running:

```bash theme={null}
sudo curl -L "https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose;
sudo chmod +x /usr/local/bin/docker-compose
```

4. **Deploy Novu**: Now, clone the Novu repository and navigate to the directory containing the docker-compose.yml file.
   To start your Novu instance, simply run:

```bash theme={null}
docker-compose up -d
```

Please note, there are user reports indicating an issue with volume persistence when deploying Novu on EC2 with Docker Compose.
You can see the discussions about this problem [here](https://github.com/novuhq/novu/issues/3339) as we do not provide official support for these types of deployments.
This is something to be aware of when deploying in this manner, and you may need to adopt additional strategies for data persistence.
Be sure to consult the Novu documentation as well as any relevant EC2 and Docker documentation for any necessary details related to your specific deployment needs.
Additionally, keep in mind that these general steps may not cover all nuances or requirements of your particular use case or the specific configuration of the Novu application.
Always ensure any deployment follows best practices for security, scalability, and maintainability.

# 🏗️ This page is still in creation process

We believe in the power of collaboration. If you have insights to share or would like to contribute to the development of this page, we welcome your input. To get involved, follow these steps:

**Open an Issue:** If you've identified an area for improvement or have a suggestion, start by opening an issue in our repository. This allows us to track and discuss the proposed changes.

**Create a Pull Request (PR):** Once you're ready to contribute, fork our repository and create a branch. Implement your changes within this branch and submit a pull request to our **Staging branch**.

By following these steps, you're helping us enhance the quality and depth of our resources. We appreciate your effort in making this page an even more valuable asset.

Your contributions drive progress. Let's build together!


# Deploy with Docker
Source: https://v0.x-docs.novu.co/self-hosting-novu/deploy-with-docker

Learn how to deploy Novu with Docker

Docker compose is the easiest way to get started with self-hosted Novu.

## Before you begin

You need the following installed in your system:

* [Docker](https://docs.docker.com/engine/install/) and [docker-compose](https://docs.docker.com/compose/install/)
* [Git](https://git-scm.com/downloads)

<iframe />

<Info>In above loom video `local/deployment` directory is used. Now it has been moved to `docker/community`. Follow below mentioned steps.</Info>

## Quick Start

### Get the code

Clone the Novu repo and enter the docker directory locally:

```bash theme={null}
# Get the code
git clone --depth 1 https://github.com/novuhq/novu

# Go to the docker community folder
cd novu/docker/community

# Copy the example env file
cp .env.example .env

# Start Novu
docker-compose -f docker-compose.yml up
```

Now visit [http://localhost:4200](http://localhost:4200/) to start using Novu.

## Securing your setup

While we provide you with some example secrets for getting started, you should NEVER deploy your Novu setup using the defaults provided.

Update the `.env` file with your own secrets.

### Required Variables:

* `JWT_SECRET`: Used by the API to generate JWT keys.
* `STORE_ENCRYPTION_KEY`: Used to encrypt/decrypt the provider credentials. It must be 32 characters long.
* `HOST_NAME`: Host name of your installation. This will be the base URL of your installation. For example, if you are deploying to server with ip `35.154.137.80`, then you should set this to `http://35.154.137.80`.

`REDIS_CACHE_SERVICE_HOST` and `REDIS_HOST` can have same value for small deployments. For larger deployments, it is recommended to use separate Redis instances for caching and queue management.

## Configuration

To keep the setup simple, we made some choices that may not be optimal for production:

* the database is in the same machine as the servers
* the storage uses localstack instead of S3

We strongly recommend that you decouple your database before deploying.

### Triggering events with custom installation

When self-hosting Novu, in order to trigger an event you must first create a new `Novu` object and configure it with the proper `backendUrl`.

```tsx theme={null}
import { Novu } from '@novu/node';

const config = {
  backendUrl: '<REPLACE_WITH_BACKEND_URL>',
};

const novu = new Novu('<API_KEY>', config);

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {},
});
```

### Pointing IFrame embed to custom installation

When using the IFrame embed to attach the notification center rather than the React component, you need to specify the `backendUrl` and the `socketUrl` when initializing the iframe.

```html theme={null}
<script>
  novu.init(
    '<REPLACE_APPLICATION_ID>',
    {
      unseenBadgeSelector: '#unseen-badge',
      bellSelector: '#notification-bell',
      backendUrl: 'https://api.example.com',
      socketUrl: 'https://ws.example.com',
    },
    {}
  );
</script>

```

### Using React Component with custom installation

See [Use your own backend and socket URL](https://docs.novu.co/notification-center/react/react-components#use-your-own-backend-and-socket-url).

### Caching

We are introducing the first stage of caching in our system to improve performance and efficiency. Caching is turned off by default, but can easily be activated by setting the following environment variables:

* REDIS\_CACHE\_SERVICE\_HOST
* REDIS\_CACHE\_SERVICE\_PORT

Currently, we are caching data in the most heavily loaded areas of the system: the widget requests such as feed and unseen count, as well as common DAL requests during the execution of trigger event flow. These are the most heavily used areas of our system, and we hope that by implementing caching in these areas, we can improve performance in the near future.

### Reverse-Proxy / Load Balancers

To implement a reverse-proxy or load balancer in front of Novu, you need to set the GLOBAL\_CONTEXT\_PATH for the base path of the application.
This is the path that the application will be served from after the domain.
For example:

* company.com/novu
  This is used to set the base path for the application, and is used to set the base path for the API, web, and websocket connections.

The following environment variables are used to set the context path for each public service that Novu provides:
API\_CONTEXT\_PATH
WIDGET\_CONTEXT\_PATH
WS\_CONTEXT\_PATH
WEB\_CONTEXT\_PATH

These allow you to set the context path for each service independently or dependently of the GLOBAL\_CONTEXT\_PATH.

For example, if I was using a reverse proxy to serve Novu from company.com/novu,
I would set the GLOBAL\_CONTEXT\_PATH to novu,
and then set the API\_CONTEXT\_PATH to api,
the WIDGET\_CONTEXT\_PATH to widget,
the WS\_CONTEXT\_PATH to ws,
and the WEB\_CONTEXT\_PATH to web.

This would produce the following urls:

* API: company.com/novu/api
* WIDGET: company.com/novu/widget
* WS: company.com/novu/ws
* WEB: company.com/novu/web

However the Service context path can be used entirely independently of the GLOBAL\_CONTEXT\_PATH.

For example, if I wanted to expose the api as novu-api, I would set the API\_CONTEXT\_PATH to novu-api without setting the GLOBAL\_CONTEXT\_PATH.
This would producte the following url:

* API: company.com/novu-api

<Note> These env variables should be present on all services novu provides due to tight coupling.</Note>


# Introduction
Source: https://v0.x-docs.novu.co/self-hosting-novu/introduction



Self-hosting Novu involves setting up and maintaining your communication infrastructure using your own servers.
While this offers full control and customization,
some features which are available only for Novu’s cloud-managed won't be available in a self-hosted environment.

## Minimum System Requirements

For basic installation, a server with 16GB RAM and 8 CPUs is fine. However, specifications vary depending on requirements and here are sample specifications for handling 1M plus notifications:

* If everything is running on one machine, then at least 36 vCPU and 64GB of RAM.
* If services are running across containers, then it is recommended to run 3 containers per service, each container having 2 vCPU and 4GB of RAM.
* If you're using Kubernetes, then the K8 system needs to have 36 vCPU and 64GB of RAM at least in the cluster to run the servers.
* On AWS, a c6g.8xlarge instance with 32 vCPU and 64GB of RAM.
* In all cases, you need to also have 2 Redis clusters with the queue one having an Append only log file active (AOL) to prevent instances of job loss during an outage,  a MongoDB cluster equivalent to a M20 or greater on Atlas, and 10GB of S3 storage.
* Lastly, the queue Redis instance should be 8GB MINIMUM as there needs to be enough space to handle spikes in notifications or the whole system will brick.

<Note>Note that these specifications are subject to your requirements, the scale of your operations, and should be adjusted as needed.</Note>
<Warning>Github login is not available in self-hosting. If you're self hosting Novu, use your email and password to log into your Novu account!</Warning>


# Kubernetes
Source: https://v0.x-docs.novu.co/self-hosting-novu/kubernetes

Learn how to deploy Novu with K8s

<Warning>
  We do not plan to support any official public kubernetes deployment at this time.
  This guide is to help assist advanced users who want to deploy Novu on their own kubernetes cluster.
</Warning>

Kubernetes is an open-source platform that automates the deployment, scaling, and management of containerized applications.

You can find a community driven [helm deployment](https://github.com/novuhq/novu/blob/next/docker/kubernetes/helm/README.md) in our repository.

## Novu Web Container Does not Run on Kubernetes

Due to the way we build our web container image,
you will need to build your own image and push it to your own registry.
This is due to us compiling the frontend when the container starts.

You can follow our [dev-deploy-web workflow](https://github.com/novuhq/novu/blob/next/.github/workflows/dev-deploy-web.yml)
to see how we build our web container image.
You can also use this workflow to build your own image, you will just need to remove all of the steps after the deploy to netlify step.

<Note>
  Only need to do this IF you do not allow root only access on your cluster.
</Note>


# Object Storage (S3, Blob, GCS)
Source: https://v0.x-docs.novu.co/self-hosting-novu/object-storage

Using S3 as a storage backend for your application

For local development we use [LocalStack.cloud](https://localstack.cloud/). It is utilized as a local emulation of S3 during development.

This might be beneficial for testing and development purposes before transitioning to actual S3 service like in a production environment.

## AWS S3

### Configuration

AWS S3 requires the following environment variables to be set:

1. S3\_REGION:
2. S3\_LOCAL\_STACK (optional): S3 endpoint to connect to, leave blank if your connecting directly to AWS
3. S3\_BUCKET\_NAME: Name of the bucket to use
4. STORAGE\_SERVICE: Name of the storage service to use, 'AWS' or 'LOCALSTACK' for S3.

### Bucket Configuration

In general, access to the S3 bucket is very permissive.

The following process is used to manage access to the S3 bucket.

General design:

* public read access (for logo and email attachments—all data is open for read to anyone)
* write access is via pre-signed url (client-side PUT to S3 after server-side request)
* private write access (get, put, delete)
* objects are written with organisationIdTenancy/objectId (at least for brand logos)

Specifics for access:

* CORS access on bucket (this is documented)
* bucket object do not need versioning (as all uploads are deemed unique)
* ACL on buckets is 'public-read' (as part of the pre-signed URLs)
* image uploads (as pre-signed) could also have rules to limit (DENY policy) on extension types (although UI also does this but leaves open a vector)
* AWS (specific): ensure that Allow owenership controls is 'BucketOwnerPreferred' to allow ACL access (rather than role/user) (ie PutObjectAcl)

### Example Terraform

```terraform theme={null}
/**
 * This sets up an S3 bucket for notifications assets (eg photos, documents). The bucket is
 * PUBLIC for read access and needs to be opened up to the API (which is deployed as an ECS task).
 *
 * It also needs to be opened up to worker (to create pre-signed urls for uploads)
 *
 * This bucket is:
 *  * public read access
 *  * private write access to the credentials (added onto the user rather than onto the bucket)
 */

#
# WARNING: this bucket uses IAM Policies and ACL for access
#
#  - @see https://binaryguy.tech/aws/s3/iam-policies-vs-s3-policies-vs-s3-bucket-acls/#:~:text=The%20biggest%20advantage%20of%20using,well%20as%20objects%20in%20it.
#  - @see https://aws.amazon.com/blogs/security/iam-policies-and-bucket-policies-and-acls-oh-my-controlling-access-to-s3-resources/
#  - @see https://stackoverflow.com/questions/47815526/s3-bucket-policy-vs-access-control-list
#
#
# TF: https://www.terraform.io/docs/providers/aws/r/s3_bucket.html
# AWS: http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/s3api/create-bucket.html
resource "aws_s3_bucket" "notifications" {
  bucket = "${var.environment}-notifications-data"
  # removed for upgrade to aws provider 4.0
  # see https://registry.terraform.io/providers/hashicorp/aws/latest/docs/guides/version-4-upgrade#acl-argument
  # acl    = "private"

  tags = {
    Environment = var.environment
    Terraform   = true
  }
}


# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_public_access_block
resource "aws_s3_bucket_public_access_block" "notifications" {
  bucket                  = aws_s3_bucket.notifications.id
  block_public_acls       = false
  # This feature protects your bucket from accidentally getting a policy that would enable public access
  # We WANT public access for read
  block_public_policy     = false
  ignore_public_acls      = false
  restrict_public_buckets = false
}


# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_ownership_controls
# this is required when setting the 'public-read' acl—without it it fails on apply
resource "aws_s3_bucket_ownership_controls" "notifications" {
  bucket = aws_s3_bucket.notifications.id

  rule {
    object_ownership = "BucketOwnerPreferred"
  }
}

# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_acl
resource "aws_s3_bucket_acl" "notifications" {
  bucket = aws_s3_bucket.notifications.id
  # Defaults to private
  # ["private" "public-read" "public-read-write" "authenticated-read" "aws-exec-read" "log-delivery-write"]
  acl    = "public-read"

  depends_on = [
    aws_s3_bucket_ownership_controls.notifications,
    aws_s3_bucket_public_access_block.notifications,
  ]
}

#
# Note: no point on having vesrioning enabled
#

#
# Restricted CORS policy but increased headers exposed (that could be further restrictred)
#
# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_cors_configuration
# AWS: https://docs.amplify.aws/lib/storage/getting-started/q/platform/js/#amazon-s3-bucket-cors-policy-setup
resource "aws_s3_bucket_cors_configuration" "notifications" {
  bucket = aws_s3_bucket.notifications.id

  cors_rule {
    allowed_headers = ["*"]
    allowed_methods = [
      "GET",
      "HEAD",
      "PUT",
    ]
    allowed_origins = ["/* OWN FQDN */"]
    expose_headers  = [
      "x-amz-server-side-encryption",
      "x-amz-request-id",
      "x-amz-id-2",
      "x-amz-meta-tag",
      "ETag"
    ]
    max_age_seconds = 3000
  }
}

resource "aws_s3_bucket_policy" "notifications" {
  bucket = aws_s3_bucket.notifications.id
  policy = data.aws_iam_policy_document.notifications-user.json
}

# [Data] IAM policy to define S3 permissions
#
# Restricting users files types to avoid problems (note: hand helds love to upload PDFs)
#
# TF: https://www.terraform.io/docs/providers/aws/d/iam_policy_document.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html
data "aws_iam_policy_document" "notifications-user" {
  statement {
    sid    = "DenyNonImage"
    effect = "Deny"
    principals {
      identifiers = [aws_iam_user.notifications.arn]
      type        = "AWS"
    }
    actions = [
      # NOTE: this is an ACL permissions
      "s3:PutObjectAcl",
    ]
    not_resources = [
      "${aws_s3_bucket.notifications.arn}/*.png",
      "${aws_s3_bucket.notifications.arn}/*.jpg",
      "${aws_s3_bucket.notifications.arn}/*.jpeg",
      "${aws_s3_bucket.notifications.arn}/*.gif"
    ]
  }
  # NOTE: these rules exist on the user policy
/*
  statement {
    effect = "Allow"
    principals {
      type        = "AWS"
      identifiers = [aws_iam_user.notifications.arn]
    }
    actions = [
      "s3:GetObject",
      "s3:DeleteObject",
      "s3:ListBucket",
      "s3:PutObject",
      # this is the magic spice, because the perms are created via ACL (rather than roles)
      "s3:PutObjectAcl"
    ]
    resources = [
      "${aws_s3_bucket.notifications.arn}*/
/*",
    ]
  }
*/
}

#######################

# TF: https://www.terraform.io/docs/providers/aws/r/iam_policy.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html
resource "aws_iam_policy" "s3" {
  name        = "ecs-app-${var.environment}-s3"
  description = "Access from the ecs tasks to s3 buckets"
  policy      = data.aws_iam_policy_document.s3.json
}

# [Data] IAM policy to define S3 permissions
# TF: https://www.terraform.io/docs/providers/aws/d/iam_policy_document.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html
data "aws_iam_policy_document" "s3" {
  statement {
    sid     = ""
    effect  = "Allow"
    actions = [
      "s3:DeleteObject",
      "s3:GetObject",
      "s3:PutObject",
      # this is the magic spice, because the perms are created via ACL (rather than roles)
      "s3:PutObjectAcl",
      "s3:ListBucket"
    ]
    resources = [
      "arn:aws:s3:::${var.assets_bucket}/*"
    ]
  }
}

######################

# Attaches a managed IAM policy to an IAM role for the ecs tasks
# TF: https://www.terraform.io/docs/providers/aws/r/iam_role_policy_attachment.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html
resource "aws_iam_role_policy_attachment" "s3" {
  role       = aws_iam_role.app_task.name  # need your role attached to whatever is doing the execution (eg workload task)
  policy_arn = aws_iam_policy.s3.arn
}
```

## Azure Blob Storage Configuration

### Configuration

Azure Blob Storage requires the following environment variables to be set:

### Required

1. STORAGE\_SERVICE: Name of the storage service to use, 'AZURE' Azure Blob.
2. AZURE\_CONTAINER\_NAME: The name of the container in your Azure Storage account that you wish to use for your blob storage.
3. AZURE\_ACCOUNT\_NAME: The name of your Azure Storage account. This is used to form the URL at which your blob storage is accessible.
4. AZURE\_ACCOUNT\_KEY: The access key for your Azure Storage account. This is used to authenticate requests made against your blob storage.
5. AZURE\_HOST\_NAME: The host name of your Azure Storage account . This is used to form the URL at which your blob storage is accessible. [Ref](https://learn.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-nodejs?tabs=managed-identity%2Croles-azure-portal%2Csign-in-azure-cli#upload-blobs-to-a-container).

### Bucket Configuration

TBD

## Google Cloud Storage Configuration

### Configuration

Google Cloud Storage requires the following environment variables to be set:

1. `GCS_BUCKET_NAME`: Name of the bucket to use.
2. `GOOGLE_APPLICATION_CREDENTIALS`: Path to the service account key file.
3. `STORAGE_SERVICE`: Name of the storage service to use, 'GCS' for Google Cloud Storage.

### Bucket Configuration

TBD


# Broadcast event to all
Source: https://v0.x-docs.novu.co/api-reference/events/broadcast-event-to-all

post /v1/events/trigger/broadcast
Trigger a broadcast event to all existing subscribers, could be used to send announcements, etc.
      In the future could be used to trigger events to a subset of subscribers based on defined filters.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.events.broadcast("<WORKFLOW_TRIGGER_IDENTIFIER>", {
    payload: {
      customKey: "customValue",
      customKey1: {
        nestedkey1: "nestedValue1"
      }
    },
    overrides: {
      email: {
        from: "support@novu.co"
      }
    },
    tenant: "tenantIdentifier"
  })
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->broadcastEvent([
      'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
      'payload' => ['customVariables' => 'Hello'],
      'transactionId' => '<REPLACE_WITH_TRANSACTION_ID>'
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'name' => 'Trigger',
      'payload' => {
          'first-name' => 'Adam',
          'last-name' => 'Eve'
      },
      'transactionId' => 'sw900999as' #optional
  }
  client.broadcast_event(payload)
  ```

  ```bash cURL theme={null}
  curl -X POST https://api.novu.co/v1/events/trigger/broadcast \
    -H "Authorization: ApiKey <NOVU_API_KEY>" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "<WORKFLOW_TRIGGER_IDENTIFIER>",
      "payload": {
        "customKey": "customValue",
        "customKey1": {
          "nestedkey1": "nestedValue1"
        }
      },
      "overrides": {
        "email": {
          "from": "support@novu.co"
        }
      },
      "tenant": "tenantIdentifier"
    }'
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
  	apiKey := "<NOVU_API_KEY>"
  	ctx := context.Background()

  	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

      name := interface{}{"<WORKFLOW_TRIGGER_IDENTIFIER>"}

  	payload := map[string]interface{}{
  		"name": "Hello World",
  		"organization": map[string]interface{}{
  			"logo": "https://happycorp.com/logo.png",
  		},
  	}

      data := novu.BroadcastEventToAll{Name: name, Payload: payload}

  	resp, err := novuClient.EventApi.BroadcastToAll(ctx, data)

  	if err != nil {
  		log.Fatal("novu error", err.Error())
  		return
  	}
  }
  ```

  ```python Python theme={null}
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  novu = EventApi(url, api_key).broadcast(
      name="<WORKFLOW_TRIGGER_IDENTIFIER>",
      payload={"customVariable": "value"},  # Optional
  )
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.events.requests.TriggerEventRequest;
  import co.novu.api.events.responses.TriggerEventResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest = new SubscriberRequest();
          subscriberRequest.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest.setFirstName("<FIRST_NAME>");
          subscriberRequest.setLastName("<LAST_NAME>");
          subscriberRequest.setPhone("<PHONE_NUMBER>");
          subscriberRequest.setAvatar("<AVATAR>");
          subscriberRequest.setSubscriberId("<SUBSCRIBER_ID>");

          TriggerEventRequest triggerEventRequest = new TriggerEventRequest();
          triggerEventRequest.setName("<NAME>"); 
          triggerEventRequest.setTo(subscriberRequest);
          triggerEventRequest.setPayload(Collections.singletonMap("<CUSTOM_VARIABLE_NAME>", "<CUSTOM_VARIABLE_VALUE>"));

          TriggerEventResponse response = novu.broadcastEvent(triggerEventRequest);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var testRecord = new TestRecord
  {
      Message = "This is a test message"
  };

  var dto = new EventTriggerDataDto()
  {
      EventName = "<WORKFLOW_TRIGGER_IDENTIFIER>",
      To =
      {
          SubscriberId = "<UNIQUE_SUBSCRIBER_IDENTIFIER>"
      },
      Payload = testRecord
  };

  var trigger = await novu.Event.TriggerBroadcastAsync(dto);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "acknowledged": true,
          "status": "processed",
          "transactionId": "string"
      }
  }
  ```
</ResponseExample>


# Bulk trigger event
Source: https://v0.x-docs.novu.co/api-reference/events/bulk-trigger-event

post /v1/events/trigger/bulk

      Using this endpoint you can trigger multiple events at once, to avoid multiple calls to the API.
      The bulk API is limited to 100 events per request.
    

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.events.bulkTrigger([
    {
      name: "<WORKFLOW_TRIGGER_IDENTIFIER>",
      to: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload: {
        customKey: "customValue",
        customKey1: {
          nestedkey1: "nestedValue1"
        }
      },
      overrides: {
        email: {
          from: "support@novu.co"
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    },
    {
      name: "<WORKFLOW_TRIGGER_IDENTIFIER>",
      to: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload: {
        customKey: "customValue",
        customKey1: {
          nestedkey1: "nestedValue1"
        }
      },
      overrides: {
        email: {
          from: "support@novu.co"
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    }
  ])
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->bulkTriggerEvent([
      [
          'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>', 
          'to' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>', 
          'payload' => ['customVariables' => 'Hello']
      ],
      [
          'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>', 
          'to' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>', 
          'payload' => ['customVariables' => 'World']
      ],
  ])->toArray();
  ```

  ```bash cURL theme={null}

  curl -X POST https://api.novu.co/v1/events/trigger/bulk \
    -H "Authorization: ApiKey <NOVU_API_KEY>" \
    -H "Content-Type: application/json" \
    -d '{
      "events": [
        {
          "name": "<WORKFLOW_TRIGGER_IDENTIFIER>",
          "to": {
            "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
            "email": "john@doemail.com"
          },
          "payload": {
            "customKey": "customValue",
            "customKey1": {
              "nestedkey1": "nestedValue1"
            }
          },
          "overrides": {
            "email": {
              "from": "support@novu.co"
            }
          },
          "actor": "actorId",
          "tenant": "tenantIdentifier"
        },
        {
          "name": "<WORKFLOW_TRIGGER_IDENTIFIER>",
          "to": {
            "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
            "email": "janet@doemail.com"
          },
          "payload": {
            "customKey": "customValue",
            "customKey1": {
              "nestedkey1": "nestedValue1"
            }
          },
          "overrides": {
            "email": {
              "from": "support@novu.co"
            }
          },
          "actor": "actorId",
          "tenant": "tenantIdentifier"
        }
      ]
    }'


  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'events' => [
          {
              'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
              'payload' => { # optional
                  'first-name' => 'Adam' # optional
              },
              'to' => {
                  'subscriberId' => '7789'
              },
              'transactionId' => '89kjfke9893' #optional
          },
          {
              'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
              'payload' => { # optional
                  'last-name' => 'Eve' # optional
              },
              'to' => {
                  'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
              },
              'transactionId' => 'sw900999as' #optional
          }
      ]
  }
  client.trigger_bulk_event(payload)
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
  	apiKey := "<NOVU_API_KEY>"
  	ctx := context.Background()

  	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

      event1 := novu.BulkTriggerOptions{
          Name: []string{"<WORKFLOW_TRIGGER_IDENTIFIER>"},
          To: map[string]interface{}{
              "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
              "email":        "john@doemail.com",
  	    },
          Payload: map[string]interface{}{
              "name": "Hello World",
              "organization": map[string]interface{}{
                  "logo": "https://happycorp.com/logo.png",
              },
  	    }
      }
      event2 := novu.BulkTriggerOptions{
          Name: []string{"<WORKFLOW_TRIGGER_IDENTIFIER>"},
          To: map[string]interface{}{
              "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
              "email":        "janet@doemail.com",
  	    },
          Payload: map[string]interface{}{
              "name": "Hello World",
              "organization": map[string]interface{}{
                  "logo": "https://happycorp.com/logo.png",
              },
  	    }
      }

      triggerPayload := []novu.BulkTriggerOptions{ event1, event2}

  	resp, err := novuClient.EventApi.TriggerBulk(ctx, triggerPayload)

  	if err != nil {
  		log.Fatal("novu error", err.Error())
  		return
  	}
  }
  ```

  ```python Python theme={null}
  from novu.dto.event import InputEventDto
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  event_1 = InputEventDto(
      name="<WORKFLOW_TRIGGER_IDENTIFIER>",  # The workflow ID is the slug of the workflow name. It can be found on the workflow page.
      recipients="<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload={},  # Your custom Novu payload goes here
  )
  event_2 = InputEventDto(
      name="<WORKFLOW_TRIGGER_IDENTIFIER>",
      recipients="<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload={},
  )

  novu = EventApi(url, api_key).trigger_bulk(
      events=[event1,event2]
  )
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.events.requests.TriggerEventRequest;
  import co.novu.api.events.pojos.BulkTriggerEventRequest;
  import co.novu.api.events.responses.BulkTriggerEventResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest = new SubscriberRequest();
          subscriberRequest.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest.setFirstName("<FIRST_NAME>");
          subscriberRequest.setLastName("<LAST_NAME>");
          subscriberRequest.setPhone("<PHONE_NUMBER>");
          subscriberRequest.setAvatar("<AVATAR>");
          subscriberRequest.setSubscriberId("<SUBSCRIBER_ID>");

          TriggerEventRequest triggerEventRequest1 = new TriggerEventRequest();
          triggerEventRequest1.setName("<NAME>");
          triggerEventRequest1.setTo(subscriberRequest);
          triggerEventRequest1.setPayload(Collections.singletonMap("<CUSTOM_VARIABLE_NAME>", "<CUSTOM_VARIABLE_VALUE>"));
          
          TriggerEventRequest triggerEventRequest2 = new TriggerEventRequest();
          triggerEventRequest2.setName("<NAME>");
          triggerEventRequest2.setTo(subscriberRequest);
          triggerEventRequest2.setPayload(Collections.singletonMap("<CUSTOM_VARIABLE_NAME>", "<CUSTOM_VARIABLE_VALUE>"));

          BulkTriggerEventRequest bulkTriggerEventRequest = new BulkTriggerEventRequest();
          bulkTriggerEventRequest.setEvents(Arrays.asList(triggerEventRequest1, triggerEventRequest2));

          BulkTriggerEventResponse response = novu.bulkTriggerEvent(bulkTriggerEventRequest);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var payload = new List<EventTriggerDataDto>()
  {
      new()
      {
          EventName = "<WORKFLOW_TRIGGER_IDENTIFIER>",
          To = { SubscriberId = "<UNIQUE_SUBSCRIBER_IDENTIFIER>"},
          Payload = new TestRecord(){ Message = "Hello"}
      },
      new()
      {
          EventName = "<WORKFLOW_TRIGGER_IDENTIFIER>",
          To = { SubscriberId = "<UNIQUE_SUBSCRIBER_IDENTIFIER>"},
          Payload = new TestRecord(){ Message = "World"}
      },
  };

  var trigger = await novu.Event.TriggerBulkAsync(payload);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": [
          {
              "acknowledged": true,
              "status": "processed",
              "transactionId": "string"
          }
      ]
  }
  ```
</ResponseExample>


# Cancel triggered event
Source: https://v0.x-docs.novu.co/api-reference/events/cancel-triggered-event

delete /v1/events/trigger/{transactionId}

    Using a previously generated transactionId during the event trigger,
     will cancel any active or pending workflows. This is useful to cancel active digests, delays etc...
    

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<Info> If `false` value is returned in response, it means that event has already been completed its execution or cancelled before. Already completed event can not be cancelled. If `true` value is returned in response, then it means that event execution has been cancelled successfully. Any digest or delay step with pending exection will also be cancelled.</Info>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.events.cancel("transactionId");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $transactionId = "transactionId";

  $novu->cancelEvent($transactionId);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.cancel_triggered_event('transactionId')
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
  	apiKey := "<NOVU_API_KEY>"
  	ctx := context.Background()

  	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

      transactionId := "<transaction_id>";

  	resp, err := novuClient.EventApi.CancelTrigger(ctx, transactionId)

  	if err != nil {
  		log.Fatal("novu error", err.Error())
  		return
  	}
  }
  ```

  ```bash cURL theme={null}

  curl --request DELETE \
    --url https://api.novu.co/v1/events/trigger/<transaction_id> \
    --header 'Authorization: ApiKey <NOVU_API_KEY>'

  ```

  ```python Python theme={null}
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  novu = EventApi(url, api_key).delete("transactionId");
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.events.responses.CancelEventResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);

          String transactionId = "<REPLACE_WITH_TRANSACTION_ID>";

          CancelEventResponse response = novu.cancelTriggeredEvent(transactionId);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var cancelled = await novu.Event.TriggerCancelAsync("triggerTransactionId");
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  { 
    data: true
  }
  ```
</ResponseExample>


# Trigger event
Source: https://v0.x-docs.novu.co/api-reference/events/trigger-event

post /v1/events/trigger

    Trigger event is the main (and only) way to send notifications to subscribers. The trigger identifier is used to match the particular workflow associated with it. Maximum number of recipients can be 100. Additional information can be passed according the body interface below.
    To prevent duplicate triggers, you can optionally pass a **transactionId** in the request body. If the same **transactionId** is used again, the trigger will be ignored. The retention period depends on your billing tier.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
    {
      to: {
        subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
        email: 'john@doemail.com',
        firstName: 'John',
        lastName: 'Doe',
      },
      payload: {
        name: "Hello World",
        organization: {
          logo: 'https://happycorp.com/logo.png',
        },
      },
    }
  );
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->triggerEvent([
      'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
      'payload' => ['customVariables' => 'Hello'],
      'to' => [
          'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          'phone' => '07983882186'
      ]
  ])->toArray();
  ```

  ```bash cURL theme={null}

  curl -X POST https://api.novu.co/v1/events/trigger \
    -H "Authorization: ApiKey <NOVU_API_KEY>" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "<WORKFLOW_TRIGGER_IDENTIFIER>",
      "to": {
        "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
        "email": "john@doemail.com",
        "firstName": "John",
        "lastName": "Doe"
      },
      "payload": {
        "name": "Hello World",
        "organization": {
          "logo": "https://happycorp.com/logo.png"
        }
      }
    }'
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
      'payload' => { # optional
          'first-name' => 'Adam' # optional
      },
      'to' => {
          'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
      },
      'transactionId' => '89kjfke9893' #optional
  }

  client.trigger_event(payload)
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
  	subscriberID := "<UNIQUE_SUBSCRIBER_IDENTIFIER>"
  	apiKey := "<NOVU_API_KEY>"
  	eventId := "<WORKFLOW_TRIGGER_IDENTIFIER>"

  	ctx := context.Background()
  	to := map[string]interface{}{
  		"lastName":     "Doe",
  		"firstName":    "John",
  		"subscriberId": subscriberID,
  		"email":        "john@doemail.com",
  	}

  	payload := map[string]interface{}{
  		"name": "Hello World",
  		"organization": map[string]interface{}{
  			"logo": "https://happycorp.com/logo.png",
  		},
  	}

  	data := novu.ITriggerPayloadOptions{To: to, Payload: payload}
  	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

  	resp, err := novuClient.EventApi.Trigger(ctx, eventId, data)

  	if err != nil {
  		log.Fatal("novu error", err.Error())
  		return
  	}
  }
  ```

  ```python Python theme={null}
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  novu = EventApi(url, api_key).trigger(
      name="<WORKFLOW_TRIGGER_IDENTIFIER>",  # This is the Workflow ID. It can be found on the workflow page.
      recipients="<UNIQUE_SUBSCRIBER_IDENTIFIER>", # The subscriber ID can be gotten from the dashboard.
      payload={},  # Your custom Novu payload goes here
  )
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.events.requests.TriggerEventRequest;
  import co.novu.api.events.responses.TriggerEventResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest = new SubscriberRequest();
          subscriberRequest.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest.setFirstName("<FIRST_NAME>");
          subscriberRequest.setLastName("<LAST_NAME>");
          subscriberRequest.setPhone("<PHONE_NUMBER>");
          subscriberRequest.setAvatar("<AVATAR>");
          subscriberRequest.setSubscriberId("<SUBSCRIBER_ID>");

          TriggerEventRequest triggerEventRequest = new TriggerEventRequest();
          triggerEventRequest.setName("<NAME>");
          triggerEventRequest.setTo(subscriberRequest);
          triggerEventRequest.setPayload(Collections.singletonMap("<CUSTOM_VARIABLE_NAME>", "<CUSTOM_VARIABLE_VALUE>"));
          
          TriggerEventResponse response = novu.triggerEvent(triggerEventRequest);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  public class OnboardEventPayload
  {
    [JsonProperty("username")]
    public string Username { get; set; }

    [JsonProperty("welcomeMessage")]
    public string WelcomeMessage { get; set; }
  }

  var onboardingMessage = new OnboardEventPayload
  {
    Username = "jdoe",
    WelcomeMessage = "Welcome to novu-dotnet"
  };

  var payload = new EventTriggerDataDto()
  {
    EventName = "onboarding",
    To = { SubscriberId = "subscriberId" },
    Payload = onboardingMessage
  };

  var trigger = await novu.Event.Trigger(payload);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "acknowledged": true,
          "status": "processed",
          "transactionId": "string"
      }
  }
  ```
</ResponseExample>

<Accordion title="Idempotent nature of transactionId">
  The `transactionId` within Novu is a unique identifier that is used to ensure the idempotent nature of notification delivery.

  When you trigger an event to send a notification, you have the option to provide a `transactionId`. If you do not provide one, Novu will generate a UUID for you.

  **This identifier is particularly useful for preventing the same notification from being sent multiple times in case the trigger event is inadvertently called more than once.**

  By leveraging the `transactionId`, you can make idempotent requests, which means if the same `transactionId` is used in another request, Novu's API will recognize it and will not send the same notification again.

  <Note>
    This upholds the principle of idempotency, ensuring that the effect of the operation is the same, no matter how many times the request is repeated with the same `transactionId`.
  </Note>
</Accordion>


# Retrieve an event
Source: https://v0.x-docs.novu.co/api-reference/notification/get-notification

get /v1/notifications/{notificationId}
Retrieve an event by its unique key identifier **notificationId**. 
    Here **notificationId** is of mongodbId type. 
    This API returns the event details - execution logs, status, actual notification (message) generated by each workflow step.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.notification

  fun main() {
      val novu = Novu(apiKey = "<NOVU_API_KEY>")
      val notification = novu.notification("<NOTIFICATION_ID>")
      println(notification)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notifications/{notificationId} \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```python Python theme={null}
  from novu.api import NotificationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  notificationApi = NotificationApi(url, api_key)

  notification = notificationApi.get("<notificationId>")
  print(notification)
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $notification = $novu->getNotification($notificationId)-toArray();
  ```
</RequestExample>


# Get notification graph statistics
Source: https://v0.x-docs.novu.co/api-reference/notification/get-notification-graph-statistics

get /v1/notifications/graph/stats

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notifications/graph/stats \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```python Python theme={null}
  from novu.api import NotificationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  notificationApi = NotificationApi(url, api_key)

  graphStats = notificationApi.graph_stats()
  list(graphStats)
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $notificationGraphStats = $novu->getNotificationGraphStats()->toArray();
  ```
</RequestExample>


# Get notification statistics
Source: https://v0.x-docs.novu.co/api-reference/notification/get-notification-statistics

get /v1/notifications/stats

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.notificationsStats

  fun main() {
      val novu = Novu(apiKey = "<NOVU_API_KEY>")
      val notificationsStats = novu.notificationsStats()
      println(notificationsStats)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notifications/stats \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```python Python theme={null}
  from novu.api import NotificationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  notificationApi = NotificationApi(url, api_key)

  notification_stats = notificationApi.stats()
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $notificationStats = $novu->getNotificationStats()->toArray();
  ```
</RequestExample>


# List all events
Source: https://v0.x-docs.novu.co/api-reference/notification/get-notifications

get /v1/notifications
List all notification events (triggered events) for the current environment. 
    This API supports filtering by **channels**, **templates**, **emails**, **subscriberIds**, **transactionId**, **topicKey**, **severity**, **contextKeys**. 
    Checkout all available filters in the query section.
    This API returns event triggers, to list each channel notifications, check messages APIs.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.dto.request.NotificationRequest
  import co.novu.extensions.notifications

  fun main() {
      val novu = Novu(apiKey = "<NOVU_API_KEY>")
      val notificationRequest = NotificationRequest("<CHANNELS>", "<TEMPLATES>", "<EMAILS>", "<SEARCH>");
      val notifications = novu.notifications(notificationRequest)
      println(notifications)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notifications \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```python Python theme={null}
  from novu.api import NotificationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  notificationApi = NotificationApi(url, api_key)

  notifications = notificationApi.list()
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $notifications = $novu->getNotifications()->toArray();
  ```
</RequestExample>


# API Overview
Source: https://v0.x-docs.novu.co/api-reference/overview

In this page you can learn about how to work with Novu's API

<Note>
  It's important to note that our API and backend SDK are intended for use
  exclusively in server-side applications. **Attempting to use them in a
  client-side application will result in Cross-Origin Resource Sharing (CORS)
  errors.** This restriction ensures the security and integrity of our services.
</Note>

## Authentication

Authentication for the Novu API involves the use of an API Key, which is a secure credential that is tied to your Novu account. This key should be included in the header of the request in the Authorization field as a string prefixed with 'ApiKey '.

```curl theme={null}
--header 'Authorization: ApiKey <NOVU_API_KEY>'
```

For example, when using Novu in a Node.js application, the Novu package should be imported and initialized with the API key, as shown in this snippet:

```javascript theme={null}
import { Novu } from "@novu/node";
const novu = new Novu("<NOVU_API_KEY>");
```

Replace `<NOVU_API_KEY>` with your actual API Key, available in the API Key section of the Novu Dashboard.

<Warning>
  It is advised not to hardcode your credentials in a file in production
  environments. Use environment variables instead.
</Warning>

## API Endpoints

Novu provides a multitude of API endpoints that enable a variety of functionalities.
the base URL for the Novu API is `https://api.novu.co/v1`.

<Note>
  We offer two API options: the US API and the EU API. By default, our API documentation refers to the US API, which can be accessed at: [https://api.novu.co/v1](https://api.novu.co/v1).

  If you require the EU version, you can access it here: [https://eu.api.novu.co/v1](https://eu.api.novu.co/v1).
</Note>

For instance, to get tenant information, the endpoint to use would include the tenant's identifier and look like this `https://api.novu.co/v1/tenants/{identifier}`.


# API Rate Limiting
Source: https://v0.x-docs.novu.co/api-reference/rate-limiting

In this page you can learn about how rate limiting works with Novu's API

<Note>
  This feature is available from v0.22.0.
</Note>

Rate limiting is an essential functionality for establishing a robust and resilient system. It safeguards system resources from being misused by malicious actors or being monopolized by one client.

A variable-cost token bucket rate limited algorithm has been added to provide the capability for different API controllers and methods to have a varying cost. It also lays a foundation for dynamic costing of resource consumption.

## Limits

The following limits apply to each category of the Novu system. Each category has an independent bucket of rate-limit tokens to consume.
Bulk requests have a rate limit cost of 100 times the base limit and consume from the same token pool. For example, the free tier would allow a combined maximum of 10 standard trigger events and 2 bulk trigger events in the same 1-second window.

| Category      | Free   | Business | Endpoints                                                            |
| ------------- | ------ | -------- | -------------------------------------------------------------------- |
| Events        | 60 rps | 600 rps  | Trigger                                                              |
| Configuration | 15 rps | 150 rps  | Subscribers, Topics, Tenants                                         |
| Global        | 30 rps | 300 rps  | All other endpoints consume rate limiting tokens from this category. |


# Bulk create subscribers
Source: https://v0.x-docs.novu.co/api-reference/subscribers/bulk-create-subscribers

post /v1/subscribers/bulk

      Using this endpoint multiple subscribers can be created at once. The bulk API is limited to 500 subscribers per request.
    

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.subscribers.bulkCreate([
      {
          subscriberId: 'test-subscriber-1',
          email: 'test-user@sd.com',
          firstName: 'subscriber-1',
          lastName: 'test-1',
      },
      {
          subscriberId: 'test-subscriber-2',
          email: 'test-user-2@sd.com',
          firstName: 'subscriber-2',
          lastName: 'test-2',
      },
      {
          subscriberId: 'test-subscriber-3',
      },
  ]);
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.subscribers.responses.CreateBulkSubscriberResponse;
  import co.novu.api.subscribers.requests.BulkSubscriberRequest;

  public class Main {
     public static void main(String[] args) {

          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest1 = new SubscriberRequest();
          subscriberRequest1.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest1.setFirstName("<FIRST_NAME>");
          subscriberRequest1.setLastName("<LAST_NAME>");
          subscriberRequest1.setPhone("<PHONE_NUMBER>");
          subscriberRequest1.setAvatar("<AVATAR>");
          subscriberRequest1.setSubscriberId("<SUBSCRIBER_ID>");

          SubscriberRequest subscriberRequest2 = new SubscriberRequest();
          subscriberRequest2.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest2.setFirstName("<FIRST_NAME>");
          subscriberRequest2.setLastName("<LAST_NAME>");
          subscriberRequest2.setPhone("<PHONE_NUMBER>");
          subscriberRequest2.setAvatar("<AVATAR>");
          subscriberRequest2.setSubscriberId("<SUBSCRIBER_ID>");

          BulkSubscriberRequest bulkSubscriberRequest = new BulkSubscriberRequest();
          bulkSubscriberRequest.setSubscribers(Arrays.asList(subscriberRequest1, subscriberRequest2));

          CreateBulkSubscriberResponse response = novu.createSubscriberBulk(bulkSubscriberRequest);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "updated": [],
          "created": [
          {
              "subscriberId": "test-subscriber-1"
          },
          {
              "subscriberId": "test-subscriber-2"
          },
          {
              "subscriberId": "test-subscriber-3"
          }
          ],
          "failed": []
      }
  }
  ```
</ResponseExample>


# Create subscriber
Source: https://v0.x-docs.novu.co/api-reference/subscribers/create-subscriber

post /v1/subscribers
Creates a subscriber entity, in the Novu platform. The subscriber will be later used to receive notifications, and access notification feeds. Communication credentials such as email, phone number, and 3 rd party credentials i.e slack tokens could be later associated to this entity.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --location 'https://api.novu.co/v1/subscribers' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <NOVU_API_KEY>' \
    --data-raw '{
      "firstName": "Pawan",
      "lastName": "Jain",
      "email": "pawan.jain@domain.com",
      "phone": "+1234567890",
      "avatar": "avatar-url",
      "locale": "en-US",
      "data": {
        "isDeveloper": true,
        "customKey": "customValue"
        }
      }'
  ```

  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.subscribers.identify("subscriberId", {
    firstName: "Pawan",
    lastName: "Jain",
    email: "pawan.jain@domain.com",
    phone: "+1234567890",
    avatar: "https://gravatar.com/avatar/553b157d82ac2880237566d5a644e5fe?s=400&d=robohash&r=x",
    locale: "en-US",
    data: {
      isDeveloper: true,
      customKey: "customValue"
    }
  });
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $novu->createSubscriber([
      'subscriberId' => 'YOUR_SYSTEM_USER_ID>',
      'email' => '<insert-email>', // optional
      'firstName' => '<insert-firstname>', // optional
      'lastName' => '<insert-lastname>', // optional
      'phone' => '<insert-phone>', //optional
      'avatar' => '<insert-avatar>', // optional
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'subscriberId' => '7789',
      'email' => '<insert-email>', # optional
      'firstName' => '<insert-firstName>', # optional
      'lastName' => '<insert-lastName>', # optional
      'phone' => '<insert-phone>', # optional
      'avatar' => '<insert-profile-avatar>' # optional
  }
  client.create_subscriber(payload)
  ```

  ```python Python theme={null}
  from novu.dto.subscriber import SubscriberDto
  from novu.api.subscriber import SubscriberApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  # Define a subscriber instance
  subscriber = SubscriberDto(
      email="novu_user@mail.com",
      subscriber_id="82a48af6ac82b3cc2157b57f", #This is what the subscriber_id looks like
      first_name="",  # Optional
      last_name="",  # Optional
      phone="",  # Optional
      avatar="",  # Optional
  )

  # Create a subscriber
  novu = SubscriberApi(url, api_key).create(subscriber)
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.subscribers.responses.CreateSubscriberResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest = new SubscriberRequest();
          subscriberRequest.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest.setFirstName("<FIRST_NAME>");
          subscriberRequest.setLastName("<LAST_NAME>");
          subscriberRequest.setPhone("<PHONE_NUMBER>");
          subscriberRequest.setAvatar("<AVATAR>");
          subscriberRequest.setSubscriberId("<SUBSCRIBER_ID>");

          CreateSubscriberResponse response = novu.createSubscriber(subscriberRequest);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var additionalData = new List<AdditionalDataDto>
  {
    new AdditionalDataDto
    {
      Key = "External ID",
      Value = "1122334455"
    },
    new AdditionalDataDto
    {
      Key = "SMS_PREFERENCE",
      Value = "EMERGENT_ONLY"
    }
  };

  var newSubscriberDto = new CreateSubscriberDto
  {
    SubscriberId = "unique_subscriber_id",
    FirstName = "John",
    LastName = "Doe",
    Avatar = "https://unslpash.com/random",
    Email = "jdoe@novu.co",
    Locale = "en-US",
    Phone = "+11112223333",
    Data = additionalData
  };

  var subscriber = await novu.Subscriber.CreateSubscriber(newSubscriberDto)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "_organizationId": "abcd12349876wxyz1234wxyz",
          "_environmentId": "zyxw4321abcd1234lmno5678",
          "firstName": "Alex",
          "lastName": "Benjamin",
          "phone": "123456789",
          "subscriberId": "abcd1234",
          "email": "alex@email.com",
          "avatar": "string",
          "locale": "en-US",
          "channels": [],
          "_id": "6516ed5a9d727fe8256028ed",
          "deleted": false,
          "createdAt": "2023-09-29T15:29:30.667Z",
          "updatedAt": "2023-09-29T15:29:30.667Z",
          "__v": 0,
          "id": "6516ed5a9d727fe8256028ed"
      }
  }
  ```
</ResponseExample>


# Delete subscriber
Source: https://v0.x-docs.novu.co/api-reference/subscribers/delete-subscriber

delete /v1/subscribers/{subscriberId}
Deletes a subscriber entity from the Novu platform

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.subscribers.delete("subscriberId");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $novu->deleteSubscriber($subscriberId);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.delete_subscriber('<insert-subscriber-id>')
  ```

  ```python Python theme={null}
  from novu.dto.event import InputEventDto
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  # Delete a subscriber
  novu = SubscriberApi(url, api_key).delete(subscriber_id)
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SubscriberDeleteResponse;

  public class Main {
     public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";

          SubscriberDeleteResponse response = novu.deleteSubscriber(subscriberId);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var deleted = await novu.Subscriber.DeleteSubscriber("subscriberId");
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "acknowledged": true,
          "status": "deleted"
      }
  }
  ```
</ResponseExample>


# Delete provider credentials
Source: https://v0.x-docs.novu.co/api-reference/subscribers/delete-subscriber-credentials-by-providerid

delete /v1/subscribers/{subscriberId}/credentials/{providerId}
Delete subscriber credentials for a provider such as **slack** and **FCM** by **providerId**. 
    This action is irreversible and will remove the credentials for the provider for particular **subscriberId**.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Retrieve subscriber notifications
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-in-app-notification-feed-for-a-particular-subscriber

get /v1/subscribers/{subscriberId}/notifications/feed
This API is deprecated, use v2 API instead. Retrieve subscriber in-app notifications by its unique key identifier **subscriberId**.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SubscriberNotificationResponse;

  public class Main {
     public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";

          SubscriberNotificationResponse response = novu.getSubscriberNotificationsFeed(subscriberId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_environmentId": "string",
        "_feedId": "string",
        "_id": "string",
        "_messageTemplateId": "string",
        "_notificationId": "string",
        "_organizationId": "string",
        "_subscriberId": "string",
        "_templateId": "string",
        "channel": "in_app",
        "createdAt": "string",
        "cta": {
          "action": {
            "buttons": [
              {
                "content": "string",
                "resultContent": "string",
                "type": "primary"
              }
            ],
            "result": {
              "payload": "object",
              "type": "primary"
            },
            "status": "pending"
          },
          "data": {
            "url": "string"
          },
          "type": "redirect"
        },
        "deviceTokens": [
          "string"
        ],
        "directWebhookUrl": "string",
        "email": "string",
        "errorId": "string",
        "errorText": "string",
        "lastSeenDate": "string",
        "overrides": "object",
        "payload": "object",
        "phone": "string",
        "providerId": "string",
        "seen": "boolean",
        "status": "sent",
        "subject": "string",
        "subscriber": {
          "__v": "number",
          "_environmentId": "string",
          "_id": "string",
          "_organizationId": "string",
          "avatar": "string",
          "channels": [
            {
              "_integrationId": "string",
              "credentials": {
                "channel": "string",
                "deviceTokens": [
                  "string"
                ],
                "webhookUrl": "string"
              },
              "integrationIdentifier": "string",
              "providerId": "slack"
            }
          ],
          "createdAt": "string",
          "deleted": "boolean",
          "email": "string",
          "firstName": "string",
          "isOnline": "boolean",
          "lastName": "string",
          "lastOnlineAt": "string",
          "locale": "string",
          "phone": "string",
          "subscriberId": "string",
          "updatedAt": "string"
        },
        "template": {
          "_creatorId": "string",
          "_environmentId": "string",
          "_id": "string",
          "_notificationGroupId": "string",
          "_organizationId": "string",
          "_parentId": "string",
          "active": "boolean",
          "critical": "boolean",
          "data": "object",
          "deleted": "boolean",
          "deletedAt": "string",
          "deletedBy": "string",
          "description": "string",
          "draft": "boolean",
          "name": "string",
          "notificationGroup": {
            "_environmentId": "string",
            "_id": "string",
            "_organizationId": "string",
            "_parentId": "string",
            "name": "string"
          },
          "preferenceSettings": {
            "chat": "boolean",
            "email": "boolean",
            "in_app": "boolean",
            "push": "boolean",
            "sms": "boolean"
          },
          "steps": [
            {
              "_id": "string",
              "_parentId": "object",
              "_templateId": "string",
              "active": "boolean",
              "filters": [
                {
                  "children": [
                    {
                      "field": "string",
                      "operator": "LARGER",
                      "true": "subscriber",
                      "value": "string"
                    }
                  ],
                  "isNegated": "boolean",
                  "type": "BOOLEAN",
                  "value": "AND"
                }
              ],
              "name": "string",
              "replyCallback": "object",
              "shouldStopOnFail": "boolean",
              "template": "object",
              "uuid": "string"
            }
          ],
          "tags": [
            "string"
          ],
          "triggers": [
            {
              "identifier": "string",
              "subscriberVariables": [
                {
                  "name": "string"
                }
              ],
              "type": "string",
              "variables": [
                {
                  "name": "string"
                }
              ]
            }
          ],
          "workflowIntegrationStatus": "object"
        },
        "templateIdentifier": "string",
        "title": "string",
        "transactionId": "string"
      }
    ],
    "hasMore": "boolean",
    "page": "number",
    "pageSize": "number"
  }
  ```
</ResponseExample>


# Get subscriber
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-subscriber

get /v1/subscribers/{subscriberId}
Get subscriber by your internal id used to identify the subscriber

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  const response = await novu.subscribers.get("subscriberId");
  console.log(response.data);
  ```

  ```bash cURL theme={null}
  curl --request GET \
    --url https://api.novu.co/v1/subscribers/{subscriberId} \
    --header 'Authorization: <authorization>'
  ```

  ```python Python theme={null}
  import requests

  url = "https://api.novu.co/v1/subscribers/{subscriberId}"

  headers = {"Authorization": "<authorization>"}

  response = requests.request("GET", url, headers=headers)

  print(response.text)
  ```

  ```javascript JavaScript theme={null}
  const options = {method: 'GET', headers: {Authorization: '<authorization>'}};

  fetch('https://api.novu.co/v1/subscribers/{subscriberId}', options)
    .then(response => response.json())
    .then(response => console.log(response))
    .catch(err => console.error(err));
  ```

  ```php PHP theme={null}
  <?php

  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://api.novu.co/v1/subscribers/{subscriberId}",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
      "Authorization: <authorization>"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://api.novu.co/v1/subscribers/{subscriberId}"

  	req, _ := http.NewRequest("GET", url, nil)

  	req.Header.Add("Authorization", "<authorization>")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SingleSubscriberResponse;

  public class Main {
     public static void main(String[] args) {
        String apiKey = "<NOVU_API_KEY>";
        Novu novu = new Novu(apiKey);
        String subscriberId = "<SUBSCRIBER_ID>";

        SingleSubscriberResponse response = novu.getSubscriber(subscriberId);
    }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "firstName": "string",
      "lastName": "string",
      "email": "string",
      "phone": "string",
      "avatar": "string",
      "locale": "string",
      "subscriberId": "string",
      "channels": [
        {
          "providerId": "slack",
          "integrationIdentifier": "string",
          "credentials": {
            "webhookUrl": "string",
            "channel": "string",
            "deviceTokens": [
              "string"
            ]
          },
          "_integrationId": "string"
        }
      ],
      "isOnline": "boolean",
      "lastOnlineAt": "string",
      "_organizationId": "string",
      "_environmentId": "string",
      "deleted": "boolean",
      "createdAt": "string",
      "updatedAt": "string",
      "__v": "number"
    }
  }
  ```
</ResponseExample>


# Get subscriber global preferences
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-subscriber-global-preferences

get /v1/subscribers/{subscriberId}/preferences/{level}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get subscriber preferences
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-subscriber-preferences

get /v1/subscribers/{subscriberId}/preferences

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SubscriberPreferenceResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";

          SubscriberPreferenceResponse response = novu.getSubscriberPreferences(subscriberId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "preference": {
          "channels": {
            "chat": "boolean",
            "email": "boolean",
            "in_app": "boolean",
            "push": "boolean",
            "sms": "boolean"
          },
          "enabled": "boolean"
        },
        "template": {
          "_id": "string",
          "critical": "boolean",
          "name": "string"
        }
      }
    ]
  }
  ```
</ResponseExample>


# Get subscribers
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-subscribers

get /v1/subscribers
Returns a list of subscribers, could paginated using the `page` and `limit` query parameter

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.BulkSubscriberResponse;

  public class Main {
     public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);

          Integer page = 0;
          Integer limit = 10;

          BulkSubscriberResponse response = novu.getSubscribers(page, limit);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "__v": "number",
        "_environmentId": "string",
        "_id": "string",
        "_organizationId": "string",
        "avatar": "string",
        "channels": [
          {
            "_integrationId": "string",
            "credentials": {
              "channel": "string",
              "deviceTokens": [
                "string"
              ],
              "webhookUrl": "string"
            },
            "integrationIdentifier": "string",
            "providerId": "slack"
          }
        ],
        "createdAt": "string",
        "deleted": "boolean",
        "email": "string",
        "firstName": "string",
        "isOnline": "boolean",
        "lastName": "string",
        "lastOnlineAt": "string",
        "locale": "string",
        "phone": "string",
        "subscriberId": "string",
        "updatedAt": "string"
      }
    ],
    "hasMore": "boolean",
    "page": "number",
    "pageSize": "number"
  }
  ```
</ResponseExample>


# Retrieve unseen notifications count
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-the-unseen-in-app-notifications-count-for-subscribers-feed

get /v1/subscribers/{subscriberId}/notifications/unseen
This API is deprecated, use v2 API instead. Retrieve unseen in-app notifications count for a subscriber by its unique key identifier **subscriberId**.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Handle chat oauth
Source: https://v0.x-docs.novu.co/api-reference/subscribers/handle-chat-oauth

get /v1/subscribers/{subscriberId}/credentials/{providerId}/oauth

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Handle providers oauth redirect
Source: https://v0.x-docs.novu.co/api-reference/subscribers/handle-providers-oauth-redirect

get /v1/subscribers/{subscriberId}/credentials/{providerId}/oauth/callback

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Mark a subscriber feed message as seen
Source: https://v0.x-docs.novu.co/api-reference/subscribers/mark-a-subscriber-feed-message-as-seen

post /v1/subscribers/{subscriberId}/messages/markAs

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update notification action status
Source: https://v0.x-docs.novu.co/api-reference/subscribers/mark-message-action-as-seen

post /v1/subscribers/{subscriberId}/messages/{messageId}/actions/{type}
This API is deprecated, use v2 API instead. Update in-app notification's action status by its unique key identifier **messageId** and type field **type**. 
      **type** field can be **primary** or **secondary**

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update all notifications state
Source: https://v0.x-docs.novu.co/api-reference/subscribers/marks-all-the-subscriber-messages-as-read-unread-seen-or-unseen-optionally-you-can-pass-feed-id-or-array-to-mark-messages-of-a-particular-feed

post /v1/subscribers/{subscriberId}/messages/mark-all
This API is deprecated, use v2 API instead. Update all subscriber in-app notifications state such as read, unread, seen or unseen by **subscriberId**.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update subscriber
Source: https://v0.x-docs.novu.co/api-reference/subscribers/update-subscriber

put /v1/subscribers/{subscriberId}
Used to update the subscriber entity with new information

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SingleSubscriberResponse;
  import co.novu.api.subscribers.requests.UpdateSubscriberRequest;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";

          UpdateSubscriberRequest updateSubscriberRequest = new UpdateSubscriberRequest();
          updateSubscriberRequest.setEmail("<EMAIL_ADDRESS>");
          updateSubscriberRequest.setFirstName("<FIRST_NAME>");
          updateSubscriberRequest.setLastName("<LAST_NAME>");
          updateSubscriberRequest.setPhone("<PHONE_NUMBER>");


          SingleSubscriberResponse response = novu.updateSubscriber(updateSubscriberRequest, subscriberId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "__v": "number",
      "_environmentId": "string",
      "_id": "string",
      "_organizationId": "string",
      "avatar": "string",
      "channels": [
        {
          "_integrationId": "string",
          "credentials": {
            "channel": "string",
            "deviceTokens": [
              "string"
            ],
            "webhookUrl": "string"
          },
          "integrationIdentifier": "string",
          "providerId": "slack"
        }
      ],
      "createdAt": "string",
      "deleted": "boolean",
      "email": "string",
      "firstName": "string",
      "isOnline": "boolean",
      "lastName": "string",
      "lastOnlineAt": "string",
      "locale": "string",
      "phone": "string",
      "subscriberId": "string",
      "updatedAt": "string"
    }
  }
  ```
</ResponseExample>


# Update provider credentials
Source: https://v0.x-docs.novu.co/api-reference/subscribers/update-subscriber-credentials

put /v1/subscribers/{subscriberId}/credentials
Update credentials for a provider such as **slack** and **FCM**. 
      **providerId** is required field. This API creates the **deviceTokens** or replaces the existing ones.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update subscriber global preferences
Source: https://v0.x-docs.novu.co/api-reference/subscribers/update-subscriber-global-preference

patch /v1/subscribers/{subscriberId}/preferences

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update subscriber online status
Source: https://v0.x-docs.novu.co/api-reference/subscribers/update-subscriber-online-status

patch /v1/subscribers/{subscriberId}/online-status
Update the subscriber online status by its unique key identifier **subscriberId**

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SingleSubscriberResponse;
  import co.novu.api.subscribers.requests.UpdateSubscriberOnlineStatusRequest;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";

          UpdateSubscriberOnlineStatusRequest request = new UpdateSubscriberOnlineStatusRequest();
          request.setIsOnline(true);

          SingleSubscriberResponse response = novu.updateSubscriberOnlineStatus(request, subscriberId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "__v": "number",
      "_environmentId": "string",
      "_id": "string",
      "_organizationId": "string",
      "avatar": "string",
      "channels": [
        {
          "_integrationId": "string",
          "credentials": {
            "channel": "string",
            "deviceTokens": [
              "string"
            ],
            "webhookUrl": "string"
          },
          "integrationIdentifier": "string",
          "providerId": "slack"
        }
      ],
      "createdAt": "string",
      "deleted": "boolean",
      "email": "string",
      "firstName": "string",
      "isOnline": "boolean",
      "lastName": "string",
      "lastOnlineAt": "string",
      "locale": "string",
      "phone": "string",
      "subscriberId": "string",
      "updatedAt": "string"
    }
  }
  ```
</ResponseExample>


# Update subscriber preference
Source: https://v0.x-docs.novu.co/api-reference/subscribers/update-subscriber-preference

patch /v1/subscribers/{subscriberId}/preferences/{templateId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.requests.UpdateSubscriberPreferenceRequest;
  import co.novu.api.subscribers.responses.SingleSubscriberPrefResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";
          String templateId = "<TEMPLATE_ID>";

          PreferenceChannel channel = new PreferenceChannel();
          channel.setType("<TYPE>");
          channel.setEnabled(true);

          UpdateSubscriberPreferenceRequest request = new UpdateSubscriberPreferenceRequest();
          request.setEnabled(false);
          request.setChannel(channel);

          SingleSubscriberPrefResponse response = novu.updateSubscriberPreferences(request, subscriberId, templateId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "preference": {
        "channels": {
          "chat": "boolean",
          "email": "boolean",
          "in_app": "boolean",
          "push": "boolean",
          "sms": "boolean"
        },
        "enabled": "boolean"
      },
      "template": {
        "_id": "string",
        "critical": "boolean",
        "name": "string"
      }
    }
  }
  ```
</ResponseExample>


# Check topic subscriber
Source: https://v0.x-docs.novu.co/api-reference/topics/check-topic-subscriber

get /v1/topics/{topicKey}/subscribers/{externalSubscriberId}
Check if a subscriber belongs to a certain topic

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Delete topic
Source: https://v0.x-docs.novu.co/api-reference/topics/delete-topic

delete /v1/topics/{topicKey}
Delete a topic by its topic key if it has no subscribers

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Filter topics
Source: https://v0.x-docs.novu.co/api-reference/topics/filter-topics

get /v1/topics
Returns a list of topics that can be paginated using the `page` query parameter and filtered by the topic key with the `key` query parameter

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get topic
Source: https://v0.x-docs.novu.co/api-reference/topics/get-topic

get /v1/topics/{topicKey}
Get a topic by its topic key

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Rename a topic
Source: https://v0.x-docs.novu.co/api-reference/topics/rename-a-topic

patch /v1/topics/{topicKey}
Rename a topic by providing a new name

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Subscribers addition
Source: https://v0.x-docs.novu.co/api-reference/topics/subscribers-addition

post /v1/topics/{topicKey}/subscribers
Add subscribers to a topic by key

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Subscribers removal
Source: https://v0.x-docs.novu.co/api-reference/topics/subscribers-removal

post /v1/topics/{topicKey}/subscribers/removal
Remove subscribers from a topic

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Topic creation
Source: https://v0.x-docs.novu.co/api-reference/topics/topic-creation

post /v1/topics
Create a topic

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get workflow groups
Source: https://v0.x-docs.novu.co/api-reference/workflow-groups/get-workflow-groups

get /v1/notification-groups
workflow group was previously named notification group

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notification-groups \
  --header 'Authorization: ApiKey <NOVU_API_KEY>' \
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationGroups.get();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->getNotificationGroups()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.notification_groups()
  ```

  ```python Python theme={null}
  from novu.api import NotificationGroupApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationGroupApi(url, api_key).list(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.notificationGroups();
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/notification-groups"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("GET", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "name": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_parentId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Create workflow overrides
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/create-workflow-overrides

post /v1/workflow-overrides

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Delete workflow override
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/delete-workflow-override

delete /v1/workflow-overrides/{overrideId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get workflow override
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/get-workflow-override

get /v1/workflow-overrides/workflows/{workflowId}/tenants/{tenantId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get workflow override by id
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/get-workflow-override-by-id

get /v1/workflow-overrides/{overrideId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get workflow overrides
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/get-workflow-overrides

get /v1/workflow-overrides

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update workflow override
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/update-workflow-override

put /v1/workflow-overrides/workflows/{workflowId}/tenants/{tenantId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update workflow override by id
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/update-workflow-override-by-id

put /v1/workflow-overrides/{overrideId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Create workflow
Source: https://v0.x-docs.novu.co/api-reference/workflows/create-workflow

post /v1/workflows
Workflow was previously named notification template

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request POST \
    --url https://api.novu.co/v1/workflows \
    --header 'Authorization: <authorization>' \
    --header 'Content-Type: application/json' \
    --data '{
      "name": "<name>",
      "notificationGroupId":"<notificationGroupId>",
      "steps": [{ "steps" }]
    }'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.create({
    name: 'Onboarding Workflow',
    // taking first workflow group id
    notificationGroupId: workflowGroupsData.data[0]._id,
    steps: [
      // Adding one chat step
      {
        active: true,
        shouldStopOnFail: false,
        // UUID is optional.
        uuid: '78ab8c72-46de-49e4-8464-257085960f9e',
        name: 'Chat',
        filters: [
          {
            value: 'AND',
            children: [
              {
                field: '{{chatContent}}',
                value: 'flag',
                operator: 'NOT_IN',
                // 'payload'
                on: FilterPartTypeEnum.PAYLOAD,
              },
            ],
          },
        ],
        template: {
          // 'chat'
          type: StepTypeEnum.CHAT,
          active: true,
          subject: '',
          variables: [
            {
              name: 'chatContent',
              // 'String'
              type: TemplateVariableTypeEnum.STRING,
              required: true,
              "defaultValue": "default message",
            },
          ],
          content: '{{chatContent}}',
          contentType: 'editor',
        },
      },
    ],
    description: 'Onboarding workflow to trigger after user sign up',
    active: true,
    draft: false,
    critical: false,
  });
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->createNotificationTemplate([
    "name" => "name",
    "notificationGroupId" => "notificationGroupId",
    "tags" => ["tags"],
    "description" => "description",
    "steps" => ["steps"],
    "active" => true,
    "draft" => true,
    "critical" => true,
    "preferenceSettings" => preferenceSettings
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  body = {
      'name' => '<insert-name>',
      'notificationGroupId' => 'notificationGroupId',
      'tags' => ['tags'], # optional
      'description' => 'description', # optional
      'steps' => [ # optional
         # insert all fields here
      ], 
      'active' => true, # optional
      'draft' => true, # optional
      'critical' => true, # optional
      'preferenceSettings' => { # optional
         # insert all fields here
      },
      'blueprintId' => 'blueprintId' # optional
  }
  client.create_notification_template(body)
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).create(
      notification_template = "< The notification template form definition>",
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.createWorkflow(body);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows"
    data := map[string]string{
      "name": "name",
      "notificationGroupId": "notificationGroupId",
      "tags": ["tags"],
      "description": "description",
      "steps": ["steps"],
      "active": true,
      "draft": true,
      "critical": true,
      "preferenceSettings": preferenceSettings,
      "blueprintId": "blueprintId",
      "data": data
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.createWorkflow

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.createWorkflow(body)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "description": "string",
      "active": true,
      "draft": true,
      "preferenceSettings": {
        "email": true,
        "sms": true,
        "in_app": true,
        "chat": true,
        "push": true
      },
      "critical": true,
      "tags": [
        "string"
      ],
      "steps": [
        {
          "_id": "string",
          "uuid": "string",
          "name": "string",
          "_templateId": "string",
          "active": true,
          "shouldStopOnFail": true,
          "template": {},
          "filters": [
            {
              "isNegated": true,
              "type": "BOOLEAN",
              "value": "AND",
              "children": [
                {
                  "field": "string",
                  "value": "string",
                  "operator": "LARGER",
                  "on": "subscriber"
                }
              ]
            }
          ],
          "_parentId": {},
          "metadata": {
            "amount": 0,
            "unit": "seconds",
            "digestKey": "string",
            "type": "regular",
            "backoff": true,
            "backoffAmount": 0,
            "backoffUnit": "seconds",
            "updateMode": true
          },
          "replyCallback": {}
        }
      ],
      "_organizationId": "string",
      "_creatorId": "string",
      "_environmentId": "string",
      "triggers": [
        {
          "type": "string",
          "identifier": "string",
          "variables": [
            {
              "name": "string"
            }
          ],
          "subscriberVariables": [
            {
              "name": "string"
            }
          ]
        }
      ],
      "_notificationGroupId": "string",
      "_parentId": "string",
      "deleted": true,
      "deletedAt": "string",
      "deletedBy": "string",
      "notificationGroup": {
        "_id": "string",
        "name": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_parentId": "string"
      },
      "data": {},
      "workflowIntegrationStatus": {}
    }
  }
  ```
</ResponseExample>


# Delete workflow
Source: https://v0.x-docs.novu.co/api-reference/workflows/delete-workflow

delete /v1/workflows/{workflowId}
Workflow was previously named notification template

***

## openapi: post /v1/workflows

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request DELETE \
    --url https://api.novu.co/v1/workflows/{workflowId} \
    --header 'Authorization: <authorization>' \
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.delete("workflowId");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->deleteNotificationTemplate($templateId);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.delete_notification_template('<insert-template-id>')
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).delete(
      notification_template_id="<The notification workflow ID of the workflow to be deleted >"
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.deleteWorkflow(workflowId);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows/:workflowId"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("DELETE", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.deleteWorkflow

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.deleteWorkflow(workflowId)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": true
  }
  ```
</ResponseExample>


# Get workflow
Source: https://v0.x-docs.novu.co/api-reference/workflows/get-workflow

get /v1/workflows/{workflowIdOrIdentifier}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request GET \
    --url https://api.novu.co/v1/workflows/{workflowIdOrIdentifier} \
    --header 'Authorization: <authorization>'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.getOne("workflowIdOrIdentifier");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getANotificationTemplate($templateId);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.notification_template('<insert-template-id>')
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).get(
      notification_template_id = "< The ID of the notification template>",
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.getWorkflow(workflowId);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("GET", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.getWorkflow

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.getWorkflow(workflowId)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "preferenceSettings": {
              "email": true,
              "sms": true,
              "in_app": true,
              "chat": true,
              "push": true
          },
          "_id": "7u83d3123t3a9e261ba9934r8",
          "name": "chat with Discord",
          "active": true,
          "draft": false,
          "critical": true,
          "isBlueprint": false,
          "_notificationGroupId": "641eddefda8256b93f750e0b",
          "tags": [],
          "triggers": [
              {
                  "type": "event",
                  "identifier": "chat-with-discord",
                  "variables": [
                      {
                          "name": "chatMsg",
                          "type": "String",
                          "_id": "7u83d3123t3a9e261ba9934r8",
                          "id": "7u83d3123t3a9e261ba9934r8"
                      }
                  ],
                  "reservedVariables": [],
                  "subscriberVariables": [],
                  "_id": "7u83d3123t3a9e261ba9934r8",
                  "id": "7u83d3123t3a9e261ba9934r8"
              }
          ],
          "steps": [
              {
                  "metadata": {
                      "timed": {
                          "weekDays": [],
                          "monthDays": []
                      }
                  },
                  "active": true,
                  "shouldStopOnFail": false,
                  "uuid": "9799f1c9-0de2-4252-8921-01840a71a741",
                  "name": "Chat",
                  "filters": [
                      {
                          "children": [],
                          "_id": "7u83d3123t3a9e261ba99376e",
                          "id": "7u83d3123t3a9e261ba993999"
                      }
                  ],
                  "_templateId": "6533d389306c4d8cf7853557",
                  "_parentId": null,
                  "_id": "99u3d3123t3a9e261ba993r45",
                  "id": "90uid3123t3a9e261ba9978yu",
                  "template": {
                      "_id": "r567d3123t3a9e261ba9990as",
                      "type": "chat",
                      "active": true,
                      "subject": "",
                      "variables": [
                          {
                              "name": "chatMsg",
                              "type": "String",
                              "required": false,
                              "_id": "2383d3123t3a9e261ba997878",
                              "id": "8711d389306c4d8cf7859090"
                          }
                      ],
                      "content": "{{chatMsg}}",
                      "contentType": "editor",
                      "_environmentId": "234edtyuda8256b93f7567f90",
                      "_organizationId": "333tydefda8256b93f753yh6",
                      "_creatorId": "63123ee5d9af70da9f6a2e4",
                      "_feedId": null,
                      "_layoutId": null,
                      "deleted": false,
                      "createdAt": "2023-10-21T13:35:05.825Z",
                      "updatedAt": "2023-10-21T13:35:18.156Z",
                      "__v": 0,
                      "id": "7u83d3123t3a9e261ba9934r8"
                  }
              }
          ],
          "_environmentId": "234edtyuda8256b93f7567f90",
          "_organizationId": "333tydefda8256b93f753yh6",
          "_creatorId": "63123ee5d9af70da9f6a2e4",
          "deleted": false,
          "createdAt": "2023-10-21T13:34:48.130Z",
          "updatedAt": "2023-10-21T13:35:18.994Z",
          "__v": 0,
          "id": "7u83d3123t3a9e261ba9934r8"
      }
  }
  ```
</ResponseExample>


# Get workflows
Source: https://v0.x-docs.novu.co/api-reference/workflows/get-workflows

get /v1/workflows
Workflows were previously named notification templates

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request GET \
    --url https://api.novu.co/v1/workflows \
    --header 'Authorization: <authorization>'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.getAll({
    page: 0, // optional
    limit: 20 // optional
  });
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getNotificationTemplates()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.notification_templates({
      'page' => 4, # optional
      'limit' => 10, # optional
  })
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).list(
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.getWorkflows(page, limit);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("GET", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.getWorkflows

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.getWorkflows(page, limit)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "page": 0,
      "data": [
          {
              "_id": "64f07ea63f28d769494bd74a",
              "name": "Chat with Novu",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "sms-docs",
                      "variables": [
                          {
                              "name": "payloadVar",
                              "type": "String",
                              "_id": "64f1df7a97770dc90cf8c951"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "64f07ea63f28d769494bd74b",
                      "reservedVariables": []
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "0c22b8e5-762f-49b3-b686-09edb2275e8d",
                      "name": "Chat",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64f1ddba1dde0257bca4352d"
                          }
                      ],
                      "_templateId": "64f1ddba1dde0257bca4351d",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64f1ddba1dde0257bca4351d",
                      "template": {
                          "_id": "64f1ddba1dde0257bca4351d",
                          "type": "chat"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-08-31T11:51:02.984Z",
              "updatedAt": "2023-09-01T12:56:26.881Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "64f024843f28d7694946d097",
              "name": "in-app workflow",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "in-app-workflow",
                      "variables": [
                          {
                              "name": "messageIdentifier",
                              "type": "String",
                              "_id": "64f02b28dd99c21f1e2d4ac7"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "64f024843f28d7694946d098"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "ba437658-522d-439f-94da-02426b42d616",
                      "name": "In-App",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64f02b1914b8a3ace6186985"
                          }
                      ],
                      "_templateId": "64f02b1914b8a3ace618697a",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64f02b1914b8a3ace618697a",
                      "template": {
                          "_id": "64f02b1914b8a3ace618697a",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-08-31T05:26:28.637Z",
              "updatedAt": "2023-08-31T05:54:48.445Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "64eec9583cd25fad61223897",
              "name": "Discord chat demo",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "discord-chat-demo",
                      "variables": [
                          {
                              "name": "chatMsg",
                              "type": "String",
                              "_id": "64eed56c735c8d00d98d2a71"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "64eec9583cd25fad61223898"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "03bb2304-d18c-4dc1-ae5a-62fe2634e787",
                      "name": "Chat",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64eeca4faed841efdcaf95eb"
                          }
                      ],
                      "_templateId": "64eeca4faed841efdcaf95e2",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64eeca4faed841efdcaf95e2",
                      "template": {
                          "_id": "64eeca4faed841efdcaf95e2",
                          "type": "chat"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-08-30T04:45:12.419Z",
              "updatedAt": "2023-08-30T05:36:44.465Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "64db9511c51d09cdd01ff086",
              "name": "testing from browser",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "testing-from-browser",
                      "variables": [],
                      "subscriberVariables": [],
                      "_id": "64db9511c51d09cdd01ff087"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "29a67140-4694-443b-b4e1-8111b399198a",
                      "name": "testting browser",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64db954a98ca413e3d6838a7"
                          }
                      ],
                      "_templateId": "64db954a98ca413e3d68389d",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64db954a98ca413e3d68389d",
                      "template": {
                          "_id": "64db954a98ca413e3d68389d",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-08-15T15:09:05.828Z",
              "updatedAt": "2023-08-25T11:55:48.583Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "64c0e3b9ec5b16b5d790d55a",
              "name": "headless-demo",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "headless-demo",
                      "variables": [
                          {
                              "name": "description",
                              "type": "String",
                              "_id": "64c0e3d2ec5b16b5d790d5f6"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "64c0e3b9ec5b16b5d790d55b"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "e0ba19d2-7833-4525-971c-4f40dd47e2ff",
                      "name": "In-App",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64c0e3d2ec5b16b5d790d5f5"
                          }
                      ],
                      "_templateId": "64c0e3d2ec5b16b5d790d5ea",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64c0e3d2ec5b16b5d790d5ea",
                      "template": {
                          "_id": "64c0e3d2ec5b16b5d790d5ea",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-07-26T09:13:29.090Z",
              "updatedAt": "2023-07-26T09:13:54.856Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "64a41ffee2134f0077e0d222",
              "name": "emailDigestWorkflow",
              "active": true,
              "draft": false,
              "critical": false,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "emaildigestworkflow",
                      "variables": [],
                      "subscriberVariables": [
                          {
                              "name": "email",
                              "_id": "64b8f8c024a8ba51900fece6"
                          }
                      ],
                      "_id": "64a41ffee2134f0077e0d223"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "13b27589-a7ad-47e3-b10d-a1085dd3687d",
                      "name": "Digest",
                      "filters": [],
                      "_templateId": "64a421ae5f8a9af84368c9fe",
                      "_parentId": null,
                      "metadata": {
                          "amount": 20,
                          "unit": "seconds",
                          "type": "regular",
                          "backoffAmount": null,
                          "backoff": false,
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64a421ae5f8a9af84368c9fe",
                      "template": {
                          "_id": "64a421ae5f8a9af84368c9fe",
                          "type": "digest"
                      }
                  },
                  {
                      "active": true,
                      "replyCallback": {
                          "active": false
                      },
                      "shouldStopOnFail": false,
                      "uuid": "4e1d8ebb-355c-4224-8a79-fcbc3c0233a1",
                      "name": "Email",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64a420215f8a9af84368b6b8"
                          }
                      ],
                      "_templateId": "64a420215f8a9af84368b6a6",
                      "_parentId": "64a421ae5f8a9af84368c9fe",
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64a420215f8a9af84368b6a6",
                      "template": {
                          "_id": "64a420215f8a9af84368b6a6",
                          "type": "email"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-07-04T13:34:54.781Z",
              "updatedAt": "2023-07-20T09:05:04.701Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "6492d92f616db8f05a982022",
              "name": "digest showcase",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "digest-showcase",
                      "variables": [],
                      "subscriberVariables": [],
                      "_id": "6492d92f616db8f05a982023"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "556f0514-01b6-46f9-9e3d-72a4c060af54",
                      "name": "Digest",
                      "filters": [],
                      "_templateId": "6492d9735da9bfaf640771a2",
                      "_parentId": null,
                      "metadata": {
                          "amount": 10,
                          "unit": "seconds",
                          "type": "regular",
                          "backoffAmount": null,
                          "backoff": false,
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "6492d9735da9bfaf640771a2",
                      "template": {
                          "_id": "6492d9735da9bfaf640771a2",
                          "type": "digest"
                      }
                  },
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "024a27f4-82da-485c-b4a7-bea05c2631e3",
                      "name": "In-App",
                      "filters": [
                          {
                              "children": [],
                              "_id": "6492d9735da9bfaf640771b6"
                          }
                      ],
                      "_templateId": "6492d9735da9bfaf640771aa",
                      "_parentId": "6492d9735da9bfaf640771a2",
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "6492d9735da9bfaf640771aa",
                      "template": {
                          "_id": "6492d9735da9bfaf640771aa",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-06-21T11:04:15.546Z",
              "updatedAt": "2023-07-19T13:32:18.474Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "6471aa6f3a4ec8a599669991",
              "name": "quickstart",
              "active": true,
              "draft": false,
              "critical": false,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "quickstart",
                      "variables": [
                          {
                              "name": "description",
                              "type": "String",
                              "_id": "6471aaa08b0b51ed173ba8fd"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "6471aa6f3a4ec8a599669992"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "982bf6a1-6f0c-46c6-a8ad-6daa67f327e2",
                      "name": "In-App",
                      "filters": [
                          {
                              "children": [],
                              "_id": "6471aa85720b54f89ed97de3"
                          }
                      ],
                      "_templateId": "6471aa85720b54f89ed97dd8",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "6471aa85720b54f89ed97dd8",
                      "template": {
                          "_id": "6471aa85720b54f89ed97dd8",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-05-27T06:59:59.254Z",
              "updatedAt": "2023-05-27T07:00:48.618Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "6469fc87301d88d6d2b74741",
              "name": "Email quickstart",
              "active": true,
              "draft": false,
              "critical": false,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "email-quickstart",
                      "variables": [
                          {
                              "name": "email",
                              "type": "String",
                              "_id": "646a031c25b1fb30f274ac35"
                          },
                          {
                              "name": "description",
                              "type": "String",
                              "_id": "646a031c25b1fb30f274ac36"
                          }
                      ],
                      "subscriberVariables": [
                          {
                              "name": "email",
                              "_id": "646a031c25b1fb30f274ac34"
                          }
                      ],
                      "_id": "6469fc87301d88d6d2b74742"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "replyCallback": {
                          "active": false
                      },
                      "shouldStopOnFail": false,
                      "uuid": "3b512084-6cba-400c-8644-d9e9bff6bbfc",
                      "name": "Email",
                      "filters": [
                          {
                              "children": [],
                              "_id": "6469fd9bc2c5b74546b2cc80"
                          }
                      ],
                      "_templateId": "6469fd9bc2c5b74546b2cc76",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "6469fd9bc2c5b74546b2cc76",
                      "template": {
                          "_id": "6469fd9bc2c5b74546b2cc76",
                          "type": "email"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-05-21T11:12:07.036Z",
              "updatedAt": "2023-05-21T11:40:12.955Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "6450b033631887e5f013f0df",
              "name": "notif-genenerator",
              "active": true,
              "draft": false,
              "critical": false,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "notif-genenerator",
                      "variables": [
                          {
                              "name": "description",
                              "type": "String",
                              "_id": "645a5b18e1a93324256bdf59"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "6450b033631887e5f013f0e0"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "0486c699-2db4-4868-9ed5-c407acacb728",
                      "name": "In-App",
                      "filters": [
                          {
                              "children": [],
                              "_id": "6450b06e9c851c56f803d489"
                          }
                      ],
                      "_templateId": "6450b06e9c851c56f803d47e",
                      "_parentId": null,
                      "_id": "6450b06e9c851c56f803d47e",
                      "template": {
                          "_id": "6450b06e9c851c56f803d47e",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-05-02T06:39:47.699Z",
              "updatedAt": "2023-05-09T14:39:20.811Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          }
      ],
      "totalCount": 20,
      "pageSize": 10
  }
  ```
</ResponseExample>


# Update workflow
Source: https://v0.x-docs.novu.co/api-reference/workflows/update-workflow

put /v1/workflows/{workflowId}
Workflow was previously named notification template

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request PUT \
    --url https://api.novu.co/v1/workflows/{workflowId} \
    --header 'Authorization: <authorization>' \
    --header 'Content-Type: application/json' \
    --data '{
      "name": "<name>",
    }'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.update("workflowId", {
    name: "Send daily digest email update",
    description: "This workflow will send daily digest email to user at 9:00 AM"
    /**
     * all other fields from create workflow payload
     */
  });
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->updateNotificationTemplate($templateId, [
    "name" => "name",
    "tags" => ["tags"],
    "description" => "description",
    "identifier" => "identifier",
    "steps" => ["steps"],
    "notificationGroupId" => "notificationGroupId",
    "active" => true,
    "critical" => true,
    "preferenceSettings" => preferenceSettings
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  body = {
      'name' => '<insert-name>',
      'notificationGroupId' => 'notificationGroupId',
      'tags' => ['tags'], # optional
      'description' => 'description', # optional
      'steps' => [ # optional
         # insert all fields here
      ], 
      'active' => true, # optional
      'draft' => true, # optional
      'critical' => true, # optional
      'preferenceSettings' => { # optional
         # insert all fields here
      },
      'blueprintId' => 'blueprintId' # optional
  }
  client.update_notification_template('<insert-template-id>', body)
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).update(
      notification_template_id = "< The ID of the notification workflow to be updated>",
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.updateWorkflow(workflowId, body);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows/:workflowId"
    data := map[string]string{
      "name": "name",
      "tags": ["tags"],
      "description": "description",
      "identifier": "identifier",
      "steps": ["steps"],
      "notificationGroupId": "notificationGroupId",
      "critical": true,
      "preferenceSettings": preferenceSettings,
      "data": data
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("PUT", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.updateWorkflow

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.updateWorkflow(workflowId, body)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "description": "string",
      "active": true,
      "draft": true,
      "preferenceSettings": {
        "email": true,
        "sms": true,
        "in_app": true,
        "chat": true,
        "push": true
      },
      "critical": true,
      "tags": [
        "string"
      ],
      "steps": [
        {
          "_id": "string",
          "uuid": "string",
          "name": "string",
          "_templateId": "string",
          "active": true,
          "shouldStopOnFail": true,
          "template": {},
          "filters": [
            {
              "isNegated": true,
              "type": "BOOLEAN",
              "value": "AND",
              "children": [
                {
                  "field": "string",
                  "value": "string",
                  "operator": "LARGER",
                  "on": "subscriber"
                }
              ]
            }
          ],
          "_parentId": {},
          "metadata": {
            "amount": 0,
            "unit": "seconds",
            "digestKey": "string",
            "type": "regular",
            "backoff": true,
            "backoffAmount": 0,
            "backoffUnit": "seconds",
            "updateMode": true
          },
          "replyCallback": {}
        }
      ],
      "_organizationId": "string",
      "_creatorId": "string",
      "_environmentId": "string",
      "triggers": [
        {
          "type": "string",
          "identifier": "string",
          "variables": [
            {
              "name": "string"
            }
          ],
          "subscriberVariables": [
            {
              "name": "string"
            }
          ]
        }
      ],
      "_notificationGroupId": "string",
      "_parentId": "string",
      "deleted": true,
      "deletedAt": "string",
      "deletedBy": "string",
      "notificationGroup": {
        "_id": "string",
        "name": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_parentId": "string"
      },
      "data": {},
      "workflowIntegrationStatus": {}
    }
  }
  ```
</ResponseExample>


# Update workflow status
Source: https://v0.x-docs.novu.co/api-reference/workflows/update-workflow-status

put /v1/workflows/{workflowId}/status
Workflow was previously named notification template

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request PUT \
    --url https://api.novu.co/v1/workflows/{workflowId}/status \
    --header 'Authorization: <authorization>' \
    --header 'Content-Type: application/json' \
    --data '{
      "active": "<boolean>",
     }'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.updateStatus("workflowId", false)
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->updateNotificationTemplateStatus($templateId, [
      'active' => true
  ])
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.update_notification_template_status('<insert-template-id>', { 'active' => true })
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).update_status(
      notification_template_id = "< The notification workflow ID of the workflow>",
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.updateWorkflowStatus(workflowId, body);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows/:workflowId/status"
    data := map[string]string{
      "active": true
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("PUT", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.updateWorkflowStatus

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.updateWorkflowStatus(workflowId, body)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "description": "string",
      "active": true,
      "draft": true,
      "preferenceSettings": {
        "email": true,
        "sms": true,
        "in_app": true,
        "chat": true,
        "push": true
      },
      "critical": true,
      "tags": [
        "string"
      ],
      "steps": [
        {
          "_id": "string",
          "uuid": "string",
          "name": "string",
          "_templateId": "string",
          "active": true,
          "shouldStopOnFail": true,
          "template": {},
          "filters": [
            {
              "isNegated": true,
              "type": "BOOLEAN",
              "value": "AND",
              "children": [
                {
                  "field": "string",
                  "value": "string",
                  "operator": "LARGER",
                  "on": "subscriber"
                }
              ]
            }
          ],
          "_parentId": {},
          "metadata": {
            "amount": 0,
            "unit": "seconds",
            "digestKey": "string",
            "type": "regular",
            "backoff": true,
            "backoffAmount": 0,
            "backoffUnit": "seconds",
            "updateMode": true
          },
          "replyCallback": {}
        }
      ],
      "_organizationId": "string",
      "_creatorId": "string",
      "_environmentId": "string",
      "triggers": [
        {
          "type": "string",
          "identifier": "string",
          "variables": [
            {
              "name": "string"
            }
          ],
          "subscriberVariables": [
            {
              "name": "string"
            }
          ]
        }
      ],
      "_notificationGroupId": "string",
      "_parentId": "string",
      "deleted": true,
      "deletedAt": "string",
      "deletedBy": "string",
      "notificationGroup": {
        "_id": "string",
        "name": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_parentId": "string"
      },
      "data": {},
      "workflowIntegrationStatus": {}
    }
  }
  ```
</ResponseExample>


# How to send PUSH notifications to iOS devices with FCM using Novu
Source: https://v0.x-docs.novu.co/guides/FCM-iOS-Novu/how-to-send-PUSH-notifications-to-iOS-devices-with-FCM-using-Novu

Learn how to integrate Firebase Cloud Messaging with Novu and send notifications to iOS

## Prerequisites

To complete this tutorial, you will need the following:

* [Apple Developer](https://developer.apple.com/) membership (to obtain the required permissions to send push notifications)
* A machine running MacOS to work on an iOS project
* [Firebase](https://firebase.google.com/) account
* [Novu](https://web.novu.co/?utm_campaign=docs-gs-guides-fcm-ios) account
* [Xcode](https://developer.apple.com/xcode/) installed on your machine

## Create an iOS app

Open Xcode and create a new project, choosing the **App** template.

Give your project a name, and select your name as the team for now, or leave it blank.

Your bundle identifier will be generated here — you will use this later when connecting to Firebase.

Select **SwiftUI** as your interface and **Swift** as your language.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Let's build and run our iOS application to see if everything works correctly.

<Frame>
  <img />
</Frame>

Go to the Firebase documentation website, go to docs here, and select Cloud Messaging.
We will follow this guide to set up cloud messaging inside the app.

You can read more about how Firebase Cloud Messaging works by reading their [official documentation](https://firebase.google.com/docs/cloud-messaging/ios/client).

<Frame>
  <img />
</Frame>

Go to iOS+ and click on the `Set up an Apple platforms client` section.

<Frame>
  <img />
</Frame>

The first thing that we need to do is add Firebase to our iOS app.
Let's create a new Firebase project inside of the console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Create a Firebase project

Select a name for your project.

<Frame>
  <img />
</Frame>

Then, add Google Analytics to the Firebase project.

<Frame>
  <img />
</Frame>

Here, you can select your Google account.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We will click on Add Firebase to your iOS app.

<Frame>
  <img />
</Frame>

We first need to add the bundle name, so go to your iOS Xcode project and copy and paste the bundle name.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Download the `.plist` file and put it in the root of your project.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

You can put it right under `info.plist` file.

<Frame>
  <img />
</Frame>

We need to add the Firebase SDK using the Swift package manager.
Copy this [https://github.com/firebase/firebase-ios-sdk](https://github.com/firebase/firebase-ios-sdk) URL and then go to 'File`->`Add Package Dependencies...\`.
Paste that URL in the top right.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We must add the initialization code to the `AppDelegates.swift` file.

Let's import the "FirebaseCore" dependency by adding `import FirebaseCore` to the beginning of the file.

Then, we will copy `firebaseapp.configure()` and place it in `didFinishLaunchingWithOptions` method.

<Frame>
  <img />
</Frame>

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore //Here

@main
class AppDelegate: UIResponder, UIApplicationDelegate {



    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure() //Here
				FirebaseConfiguration.shared.setLoggerLevel(.min)
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

```

Click 'Next' and continue to the console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Let's build and run our project and see if we get Firebase log messages in the console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Create and upload our APNs authentication key

We will create and upload our APNs authentication key to the Firebase project settings.

<Frame>
  <img />
</Frame>

Navigate to [Apple Developer Member Center](https://developer.apple.com/account).

Head to the "Keys" section under "Certificates, IDs & Profiles".

<Frame>
  <img />
</Frame>

Create a new key.

<Frame>
  <img />
</Frame>

Select "Apple Push Notification Service".

<Frame>
  <img />
</Frame>

Click "Register".

<Frame>
  <img />
</Frame>

We have to download this key and upload it into Firebase.

<Frame>
  <img />
</Frame>

Head to "Project Settings".

<Frame>
  <img />
</Frame>

Click on Cloud Messaging, then click "Upload APNs Authentication Key".

<Frame>
  <img />
</Frame>

Now we can upload the dots p8 file.

<Frame>
  <img />
</Frame>

You must enter your `Key ID` and `Team ID`, which you can find in the top right corner.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Register for Remote Notifications

<Frame>
  <img />
</Frame>

1. Copy this code block and place it inside the `AppDelegate.swift` file using the `didFinishLaunchingWithOptions` method.
   We paste this code block under `firebaseApp.configure()`.

2. We need to conform to this delegate, so we will also create an `AppDelegate` extension at the bottom for `UNUserNotificationCenterDelegate`.

3. Add `import FirebaseMessaging` to the file.

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {



    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
}

```

## Access the Registration Token

To do this, we must first set the `Messaging.messaging().delegate = self` inside the `didFinishLaunchingWithOptions` method.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We will now add a 'Messaging' delegate extension to `AppDelegate.swift` file.

<Frame>
  <img />
</Frame>

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce on 13/01/2024.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {



    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        FirebaseConfiguration.shared.setLoggerLevel(.min)

        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()
        
        // Messaging Delegate
        
        Messaging.messaging().delegate = self

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
      // Receive displayed notifications for iOS 10 devices.
      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  willPresent notification: UNNotification) async
        -> UNNotificationPresentationOptions {
        let userInfo = notification.request.content.userInfo

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // ...

        // Print full message.
        print(userInfo)

        // Change this to your preferred presentation option
        return [[.alert, .sound]]
      }

      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  didReceive response: UNNotificationResponse) async {
        let userInfo = response.notification.request.content.userInfo

        // ...

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // Print full message.
        print(userInfo)
      }
    }
    


extension AppDelegate: MessagingDelegate {
  
  func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
    print("Firebase registration token: \(String(describing: fcmToken))")
    
    let dataDict: [String: String] = ["token": fcmToken ?? ""]
    NotificationCenter.default.post(
      name: Notification.Name("FCMToken"),
      object: nil,
      userInfo: dataDict
    )
    // TODO: If necessary send token to application server.
    // Note: This callback is fired at each app startup and whenever a new token is generated.
  }
  
  
}

```

## Receive messages in an Apple App

1. Copy this code block and place it in `UNUserNotificationCenterDelegate` extension.
2. Add the `didReceiveRemoteNotification`.
3. We must declare a `gcmMessageIDKey` inside of `AppDelegate`. We can define this as a `string` variable.

<Frame>
  <img />
</Frame>

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    let gcmMessageIDKey = "gcm.Message_ID"

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        FirebaseConfiguration.shared.setLoggerLevel(.min)

        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()
        
        // Messaging Delegate
        
        Messaging.messaging().delegate = self

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
      // Receive displayed notifications for iOS 10 devices.
      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  willPresent notification: UNNotification) async
        -> UNNotificationPresentationOptions {
        let userInfo = notification.request.content.userInfo

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // ...

        // Print full message.
        print(userInfo)

        // Change this to your preferred presentation option
        return [[.alert, .sound]]
      }

      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  didReceive response: UNNotificationResponse) async {
        let userInfo = response.notification.request.content.userInfo

        // ...

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // Print full message.
        print(userInfo)
      }
    
    func application(_ application: UIApplication,
                     didReceiveRemoteNotification userInfo: [AnyHashable: Any]) async
      -> UIBackgroundFetchResult {
      // If you are receiving a notification message while your app is in the background,
      // this callback will not be fired till the user taps on the notification launching the application.
      // TODO: Handle data of notification

      // With swizzling disabled you must let Messaging know about the message, for Analytics
      // Messaging.messaging().appDidReceiveMessage(userInfo)

      // Print message ID.
      if let messageID = userInfo[gcmMessageIDKey] {
        print("Message ID: \(messageID)")
      }

      // Print full message.
      print(userInfo)

      return UIBackgroundFetchResult.newData
    }

    
    }
    


extension AppDelegate: MessagingDelegate {
  
  func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
    print("Firebase registration token: \(String(describing: fcmToken))")
    
    let dataDict: [String: String] = ["token": fcmToken ?? ""]
    NotificationCenter.default.post(
      name: Notification.Name("FCMToken"),
      object: nil,
      userInfo: dataDict
    )
    // TODO: If necessary send token to application server.
    // Note: This callback is fired at each app startup and whenever a new token is generated.
  }
  
  
}

```

## Adding app capabilities

<Frame>
  <img />
</Frame>

Click on the plus sign (+) and select `Background Modes`.

<Frame>
  <img />
</Frame>

**Select the following options:**

* Background Fetch
* Remote Notifications
* Background Processing

<Frame>
  <img />
</Frame>

Add `Push Notifications` capabilities.

<Frame>
  <img />
</Frame>

## App Build

<Frame>
  <img />
</Frame>

It will ask if you want to receive notifications, and we will allow it.

<Frame>
  <img />
</Frame>

## Cloud Message Test

In your Firebase project, navigate to 'engage' section and click on 'messaging'.

<Frame>
  <img />
</Frame>

Click on "Send your first message".

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We're going to enter the `notification title` and the `notification text`, then we're going to send the test message.

<Frame>
  <img />
</Frame>

We must copy and paste this FCM registration token to confirm our device (A physical or a simulator). You can find it in your Xcode console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Click on 'Test'.

<Frame>
  <img />
</Frame>

You should see the notification on your device!

<Frame>
  <img />
</Frame>

## Novu account creation

<Frame>
  <img />
</Frame>

You can immediately configure FCM as a Push channel provider or navigate to the Integration Store.

<Frame>
  <img />
</Frame>

## Connecting FCM as a provider

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

You only need to configure FCM with Novu with the Firebase Service Accounts private key.

To acquire the account key JSON file for your service account, follow this instructions:

1. Select your project. Click the gear icon on the top of the sidebar.
2. Head to project settings.
3. Navigate to the service account tab.
4. Click "Generate New Private Key", then confirm by clicking "Generate Key".
5. Clicking Generate Key will download the JSON file.
6. Once the file is on your machine, paste the entire JSON file content in the Service Account field of the FCM provider in the integration store on Novu’s web dashboard.

Make sure your service account key JSON content contains these fields:

```JSON theme={null}

{
  "type": "service_account",
  "project_id": "PROJECT_ID",
  "private_key_id": "PRIVATE_KEY_ID",
  "private_key": "PRIVATE_KEY",
  "client_email": "FIREBASE_ADMIN_SDK_EMAIL",
  "client_id": "CLIENT_ID",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "CLIENT_X509_CERT_URL"
}

```

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Creating a workflow

In Novu, creating a workflow means establishing a blueprint for sending notifications within your app. This unified structure ties together email, in-app messages, SMS, push notifications, and chat into **one entity**.

Each workflow has a unique name and identifier and includes customized content for various channels, using `{{handlebars}}` variables for personalization.

This ensures consistent platform notifications and allows dynamic adjustments for individual subscribers, scenarios, and use cases.

Workflow creation is for streamlining automated notifications, enabling teams to communicate effectively without extensive technical expertise.

<Steps>
  <Step title="Nabigate to 'Workflows' tab and click on 'Blank Workflow'">
    <Frame>
      <img />
    </Frame>

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Add (Drag & Drop) the Push channel node to the workflow">
    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Click on the node, and start to modify the content. Once you are done, click on 'Update'">
    <Frame>
      <img />
    </Frame>
  </Step>
</Steps>

## Creating a subscriber

Creating a subscriber in Novu refers to the process of establishing a subscriber entity within the Novu platform. A subscriber is essentially the recipient of the notifications sent through Novu's system. When you create a subscriber, you're setting up the necessary information for Novu to send targeted notifications to that individual.

<Frame>
  <img />
</Frame>

<Steps>
  <Step title="Creating a subscriber">
    ```JSON theme={null}

    curl --location 'https://api.novu.co/v1/subscribers' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <YOUR_API_KEY>' \
    --data-raw '{
    "subscriberId": "12345678",
    "firstName": "Pawan",
    "lastName": "Jain",
    "email": "pawan.jain@domain.com",
    "phone": "+1234567890",
    "avatar": "avatar-url",
    "locale": "en-US",
    "data": {
      "isDeveloper": true,
      "customKey": "customValue"
      }
    }'

    ```

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Locating subscriber's FCM registration token">
    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Adding the registration token to the subscriber">
    <Note> Subscriber can have multiple device tokens </Note>

    Here, you can locate the Provider\_Identifier.

    <Frame>
      <img />
    </Frame>

    ```JSON theme={null}

        curl --request PUT \
      --url https://api.novu.co/v1/subscribers/{subscriber_id}/credentials \
    --header 'Content-Type: application/json' \
      --header 'Authorization: ApiKey <YOUR_API_KEY>' \
      --data '{
      "credentials":{
        "deviceTokens": ["token1", "token2"]
    },
      "integrationIdentifier":"<Provider_Identifier>",
      "providerId":"fcm"
    }'

    ```
  </Step>
</Steps>

## Sending a notification to iOS device with Novu

To send a notification with Novu, you are actually triggering a notification workflow.
You have the ability to test the trigger using the user interface or by calling Novu's API.

**Trigger a workflow via the API**

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "<REPLACE_WITH_DATA>"
         },
         "payload": {}
       }'

```

<Frame>
  <img />
</Frame>

## Dynamic Content

When we were creating the first workflow, we "Hardcoded" the content of the notification.

Now, we will determine the content when calling the API.

1. In the workflow, we should change the values of the `title` and the `body` to `{{title}}` and `{{body}}`.
   That way, we could insert values through the payload of the API call.

<Frame>
  <img />
</Frame>

2. Add a 'payload' object to the API call.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "This title was set via the Payload",
           "body": "Payload notification body"
         },
       }'

```

<Frame>
  <img />
</Frame>

## Sound of a notification

The name of a sound file in your app's main bundle or in the Library/Sounds folder of your app's container directory.
Specify the string "default" to play the system sound.

Use this key for regular notifications. For critical alerts, use the sound dictionary instead.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "Notification With Sound",
           "body": "Hello World from Novu"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "payload": {
                 "aps": {
                   "sound": "default" // configure sound to the notification
                 }
               }
             }
           }
         }
       }'

```

## Priority for notification

If you omit this header, APNs set the notification priority to `10`.

Specify `10` to send the notification immediately.

Specify `5` to send the notification based on power considerations on the user’s device.

Specify `1` to prioritize the device’s power considerations over all other factors for delivery and prevent awakening the device.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "apns-priority: 5",
           "body": "Novu's API"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "headers": {
				 "apns-priority":"5" //priority for notifications
			   },
               "payload": {
                 "aps": {}
               },
               "fcm_options": {}
             }
           }
         }
       }'

```

## Sending images

Up to this point, your notifications have all contained only text. But if you’ve received many notifications, you know that notifications can have rich content, such as images. It’d be great if your notifications showed users a nice image related to their content. Once again, Firebase makes this super simple.

To show an image in push notifications, you’ll need to create a ***Notification Service Extension***. This is a separate target in your app that runs in the background when your user receives a push notification. The service extension can receive a notification and change its contents before iOS shows the notification to the user.
You’ll use Firebase to send an image URL inside a notification.
You’ll then use a content extension to download the image and add it to the notification’s content.

In Xcode, go to File ▸ New ▸ Target…. Search for Notification Service Extension and select Next. Set a name and configure it to add to your main project.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Select **Finish**, and when prompted, select **Activate**.

<Frame>
  <img />
</Frame>

When you added the Firebase package to your project, it was only added to the your "main" (In my case it's "PushNotificationDemo") target, so now you need to add the necessary dependency to your new extension.
Open your app’s project settings and select the name you picked for the extention under Targets.

Under Frameworks and Libraries, select the + button, and search for FirebaseMessaging. Then, select Add. Your project should reflect the image below:

<Frame>
  <img />
</Frame>

Select the + button, and search for FirebaseMessaging. Then, select Add.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Now, open `NotificationService.swift`. This file is where you can customize notifications before the user sees them.

First, add the following import to the top of the file:
`import FirebaseMessaging`

Next, replace the contents of `didReceive(_:withContentHandler:)` with the following:

```Swift theme={null}

self.contentHandler = contentHandler
bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)
        
if let bestAttemptContent = bestAttemptContent {
// Modify the notification content here...
bestAttemptContent.title = "\(bestAttemptContent.title)"
            
// Call FIRMessaging extension helper API.

if let messagingContentHandler = self.contentHandler {
Messaging.serviceExtension().populateNotificationContent(bestAttemptContent, withContentHandler: messagingContentHandler)
 }
}

```

Typically, you’d have to search the field containing the image URL, download the image, and finish the presentation with the picture as an attachment.
Here, you’re using Firebase’s `FIRMessagingExtensionHelper` to perform all that work automatically in a straightforward helper method call.

Remember, iOS only allows you to download your attached image. If the extension’s code takes too long to run, the system will call `serviceExtensionTimeWillExpire()`.
This gives you a chance to gracefully finish up anything you are doing in the extension or to simply present the notification as is, which is the default implementation.

This is the entire `NotificationService.swift` file.

```Swift theme={null}

//
//  NotificationService.swift
//  Rich Notifications
//
//  Created by Emillien Pearce.
//

import UserNotifications
import FirebaseMessaging

class NotificationService: UNNotificationServiceExtension {

    var contentHandler: ((UNNotificationContent) -> Void)?
    var bestAttemptContent: UNMutableNotificationContent?

    override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
        
        self.contentHandler = contentHandler
        bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)
        
        if let bestAttemptContent = bestAttemptContent {
            // Modify the notification content here...
            bestAttemptContent.title = "\(bestAttemptContent.title)"
            
            // Call FIRMessaging extension helper API.
            if let messagingContentHandler = self.contentHandler {
                Messaging.serviceExtension().populateNotificationContent(bestAttemptContent, withContentHandler: messagingContentHandler)
            }
        }
    }
    
    override func serviceExtensionTimeWillExpire() {
        // Called just before the extension will be terminated by the system.
        // Use this as an opportunity to deliver your "best attempt" at modified content, otherwise the original push payload will be used.
        if let contentHandler = contentHandler, let bestAttemptContent =  bestAttemptContent {
            contentHandler(bestAttemptContent)
        }
    }

}

```

Let's **rebuild** our app again!

<Frame>
  <img />
</Frame>

When making the API call, we should include:

* "mutable-content": 1 inside the "aps" object.
* "image" in "fcm\_options" object,
* URL address of the image.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "This is a notification with an image",
           "body": "Check this out"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "headers": {},
               "payload": {
        "aps": {
          "mutable-content": 1
                 }
               },
      "fcm_options": {
        "image": "https://www.planetware.com/wpimages/2020/02/france-in-pictures-beautiful-places-to-photograph-eiffel-tower.jpg"
               }
             }
           }
         }
       }'

```

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Sending actionable notifications

1. Define Notification Actions:

In your `AppDelegate.swift` file, you should define the notification actions you want to add.
You can do this by creating a `UNNotificationAction` for each action you want to include.
For example, let's add two actions: "Accept" and "Reject".

```Swift theme={null}

// Add these lines inside your AppDelegate class, preferably below the existing extensions.

extension UNNotificationAction {
    static let accept = UNNotificationAction(
        identifier: "ACCEPT_ACTION",
        title: "Accept",
        options: [.foreground]
    )
    
    static let reject = UNNotificationAction(
        identifier: "REJECT_ACTION",
        title: "Reject",
        options: [.destructive, .foreground]
    )
}

```

2. Register Notification Category:

   You need to register the notification category with the actions you defined in your `didFinishLaunchingWithOptions` method:

   ```
   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
   // ... (your existing code)

   // Register notification category
   let acceptAction = UNNotificationAction.accept
   let rejectAction = UNNotificationAction.reject

   let messageCategory = UNNotificationCategory(
       identifier: "MESSAGE_CATEGORY",
       actions: [acceptAction, rejectAction],
       intentIdentifiers: [],
       options: []
   )

   UNUserNotificationCenter.current().setNotificationCategories([messageCategory])

   return true
   ```

}

````

3. Handle Action Taps:

Now, you need to handle the action taps in the `userNotificationCenter(_:didReceive response:)` method of your `AppDelegate`. 
You can check which action was tapped by inspecting the `response.actionIdentifier` property:

```Swift

func userNotificationCenter(_ center: UNUserNotificationCenter,
                            didReceive response: UNNotificationResponse) async {
    let userInfo = response.notification.request.content.userInfo

    if response.actionIdentifier == UNNotificationAction.accept.identifier {
        // Handle the "Accept" action
        print("User tapped Accept")
        // Perform the desired action for "Accept"
    } else if response.actionIdentifier == UNNotificationAction.reject.identifier {
        // Handle the "Reject" action
        print("User tapped Reject")
        // Perform the desired action for "Reject"
    } else {
        // Handle other actions or default behavior
        print("User tapped an action with identifier: \(response.actionIdentifier)")
    }
}

````

Your full `AppDelegate.swift` file should look like this:

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    let gcmMessageIDKey = "gcm.Message_ID"

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        FirebaseConfiguration.shared.setLoggerLevel(.min)

        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()
        
        // Register notification category
        let acceptAction = UNNotificationAction.accept
        let rejectAction = UNNotificationAction.reject
        
        let messageCategory = UNNotificationCategory(
            identifier: "MESSAGE_CATEGORY",
            actions: [acceptAction, rejectAction],
            intentIdentifiers: [],
            options: []
        )
        
        UNUserNotificationCenter.current().setNotificationCategories([messageCategory])
        
        // Messaging Delegate
        
        Messaging.messaging().delegate = self

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
      // Receive displayed notifications for iOS 10 devices.
      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  willPresent notification: UNNotification) async
        -> UNNotificationPresentationOptions {
        let userInfo = notification.request.content.userInfo

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // ...

        // Print full message.
        print(userInfo)

        // Change this to your preferred presentation option
        return [[.alert, .sound]]
      }

      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  didReceive response: UNNotificationResponse) async {
        let userInfo = response.notification.request.content.userInfo
          
          if response.actionIdentifier == UNNotificationAction.accept.identifier {
               // Handle the "Accept" action
               print("User tapped Accept")
               // Perform the desired action for "Accept"
           } else if response.actionIdentifier == UNNotificationAction.reject.identifier {
               // Handle the "Reject" action
               print("User tapped Reject")
               // Perform the desired action for "Reject"
           } else {
               // Handle other actions or default behavior
               print("User tapped an action with identifier: \(response.actionIdentifier)")
           }

        // ...

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // Print full message.
        print(userInfo)
          
          
      }
    
    func application(_ application: UIApplication,
                     didReceiveRemoteNotification userInfo: [AnyHashable: Any]) async
      -> UIBackgroundFetchResult {
      // If you are receiving a notification message while your app is in the background,
      // this callback will not be fired till the user taps on the notification launching the application.
      // TODO: Handle data of notification

      // With swizzling disabled you must let Messaging know about the message, for Analytics
      // Messaging.messaging().appDidReceiveMessage(userInfo)

      // Print message ID.
      if let messageID = userInfo[gcmMessageIDKey] {
        print("Message ID: \(messageID)")
      }

      // Print full message.
      print(userInfo)
          
          

      return UIBackgroundFetchResult.newData
    }

    
    }
    


extension AppDelegate: MessagingDelegate {
  
  func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
    print("Firebase registration token: \(String(describing: fcmToken))")
    
    let dataDict: [String: String] = ["token": fcmToken ?? ""]
    NotificationCenter.default.post(
      name: Notification.Name("FCMToken"),
      object: nil,
      userInfo: dataDict
    )
    // TODO: If necessary send token to application server.
    // Note: This callback is fired at each app startup and whenever a new token is generated.
  }
  
  
}

extension UNNotificationAction {
    static let accept = UNNotificationAction(
        identifier: "ACCEPT_ACTION",
        title: "Accept",
        options: [.foreground]
    )
    
    static let reject = UNNotificationAction(
        identifier: "REJECT_ACTION",
        title: "Reject",
        options: [.destructive, .foreground]
    )
}

```

Now, let’s trigger a notification with actionable buttons:

```JSON theme={null}

curl --location --request POST "https://api.novu.co/v1/events/trigger" \
     --header "Authorization: ApiKey 4de014990cfb201033014548be2db904" \
     --header "Content-Type: application/json" \
     --data-raw '{
    "name": "untitled",
    "to": {
        "subscriberId": "12345678"
    },
    "payload": {
        "title": "New Mission",
        "body": "Your mission, should you choose to accept it,"
    },
    "overrides": {
        "fcm": {
            "apns": {
                "payload": {
                    "aps": {
                        "category": "MESSAGE_CATEGORY"
                    }
                }
            }
        }
    }
}'

```

<Frame>
  <img />
</Frame>

## Additional resources

* [Generating a remote notification by Apple](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/generating_a_remote_notification)
* [Sending notification requests to APNs](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/sending_notification_requests_to_apns)


# How to Add Digest to Email Notifications
Source: https://v0.x-docs.novu.co/guides/add-digest-to-email-notifications

Leverage the digest functionality to send email notifications

# Introduction

In this guide, you’ll learn how to add digest functionality to email notifications. But before exploring the actual code, let’s understand what a digest notification is and how it works.

You can find the entire code(frontend as well as backend) for this app [here](https://github.com/novuhq/digest-email-app).

<Note>
  If, instead, you want to add digest to in-app notifications, we have a guide for that as well. Take a look [here](/guides/add-digest-to-inapp-notifications).
</Note>

### What is a Digest Notification?

Often when you associate notifications with user activity, the end user can be bombarded with messages because of the nature of the activity. Take for example the case of commenting in the context of a social media app. If you were to send a notification to a user for every comment they receive, and they happen to receive 100 comments, it could lead to user fatigue since you would have to send 100 messages.

This is where digest notifications come into the picture!

A digest notification is a notification that consolidates information from several notifications into one and delivers that notification to the end user instead of several separate messages.

### How does Digest Notification Work?

Novu has a built-in digest engine that collects multiple trigger events, aggregates them into a single message, and delivers it to the subscriber. You can use the digest engine by adding a ‘digest node’ to your workflow in the workflow editor in the [Novu dashboard](https://web.novu.co/workflows?utm_campaign=docs-digests). If you want to learn more about it, [this](/getting-started/concepts#digest) is a great place to start.

Let’s see it in action now!

# Add Digest Notification To An App

To get started with this, you need the following:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-digests) if you don’t have one yet.
* A working React development environment.

# Workflow setup in Novu

Once, you have these, follow the steps below:

1. Head over to the Novu Dashboard.
2. Click `Workflows` on the left sidebar of your Novu dashboard.
3. Click the `Create Workflow` button on the top right:

<Frame>
  <img />
</Frame>

Once you click the `create workflow` button, you’ll see a dropdown. Select `blank workflow` from the dropdown:

<Frame>
  <img />
</Frame>

You’ll now be taken to the workflow editor:

<Frame>
  <img />
</Frame>

Once here, you can add the channels you want to use for sending notifications and configure them. For this guide, we’ll use the `Email` channel. You’ll also see the `Digest` action on the right sidebar.

<Note>
  Each node that is added below the digest node will only be triggered after the specified time interval
</Note>

For example, in our case, say we want the email notification to be sent after every 6 hours. So, add the `digest` action below the `trigger node`, and add the `email` channel node below the `digest` node as shown below:

<Frame>
  <img />
</Frame>

The `digest` node allows you to set a specific time interval for when notifications should be sent:

<Frame>
  <img />
</Frame>

Once, you’ve configured it. Go ahead and configure the `email` channel as per your need:

<Frame>
  <img />
</Frame>

Here’s a brief explanation of all the options:

* **1-Preview:** This shows you a glimpse of what the email notification item will look like when delivered to the client.
* **2-Sender Name:** Lets you set the sender name for emails that the client will receive.
* **3-Subject:** This lets you define the subject line for the emails that the client will receive.
* **4-Filter:** This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.
* **5-Custom Code** - In custom code, you can write custom digest templates to show some/all parts of a message.
* **6-Test** - This allows you to send a test email to test if everything is working as per your wish.

You can write your own digest template in the 'custom code' section or just follow this guide as shown in the picture above. Once you’re done configuring this to your liking, click on the `update` button on the top right.

It’ll automatically create a trigger code that you can use in your app. To get it, click on the `get snippet` button on the top right and copy it:

<Frame>
  <img />
</Frame>

Now, let’s see how to add Novu to our app!

# Add Novu to the Backend and Configure it

In your backend, install the novu package using the following code:

```bash theme={null}
npm install @novu/node

```

Now, create a route that you want to hit when called from the front end. In our demo app, this is the route:

```jsx theme={null}
import express from 'express';

import { getEmailDigest } from '../controller/emaildigest.js';

const router = express.Router();

router.post('/sending-email-digest', getEmailDigest);

export default router;
```

Now, we need to write a controller function that will handle the logic for what is to be sent in the trigger function’s payload. In our case, this is the controller function:

```jsx theme={null}
import { sendEmailDigest } from '../novu/novu.js';

export const getEmailDigest = async (req, res) => {
  const { notif, email } = req.body;
  try {
    await sendEmailDigest(notif, email);
    res.status(201).json({ message: 'success', notif: notif });
  } catch (error) {
    res.status(409).json({ message: error.message });
  }
};
```

To make it modular, we’ll keep the trigger code in a separate function in a separate file (`novu.js`, in our case) and the trigger function is getting called in the controller function above by the name `getEmailDigest`.

If you’re following the guide, you’ve already copied the trigger function. But before we can add it to our app, we need one key thing - Subscribers.

Subscribers are users to which the notifications are sent. You can see a list of subscribers in the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-digests) as well.

In our app, we’ll create a subscriber in Node.js as we’re writing our backend in Node.js, but we also have backend [SDKs](/sdks/introduction) ([Node.js](https://github.com/novuhq/novu/tree/next/packages/node), [PHP](https://github.com/novuhq/novu-php), [.NET](https://github.com/novuhq/novu-dotnet), [Elixir](https://github.com/novuhq/novu-elixir), [Go](https://github.com/novuhq/go-novu), [Ruby](https://github.com/novuhq/novu-ruby), [Python](https://github.com/novuhq/novu-python), and [Kotlin](https://github.com/novuhq/novu-kotlin)) to choose from. The recommended way to create a subscriber in NodeJS is as follows:

```jsx theme={null}
await novu.subscribers.identify('digestEmailSub', {
  firstName: 'digest email subscriber',
  email: email,
});
```

Here, we’re creating a subscriber with the `subscriberID` of `digestEmailSub.` In most real-world scenarios, the `subscriberId` should be an alphanumeric entity like `adfa67y87ad0`. You can read more about subscribers [here](https://docs.novu.co/platform/subscribers/).

Back in our app, we can now add the trigger function:

```jsx theme={null}
import { Novu } from '@novu/node';

export const sendEmailDigest = async (notif, email) => {
  const novu = new Novu(process.env.YOUR_NOVU_API_KEY);
  await novu.subscribers.identify('digestEmailSub', {
    firstName: 'digest email subscriber',
    email: email,
  });

  novu.trigger('emaildigestworkflow', {
    to: {
      subscriberId: 'digestEmailSub',
      email: email,
    },
    payload: {
      notif: notif,
    },
  });
};
```

Now, we just need to hit the route defined above from the front end.

# Hit the backend route from the front end

From the front end, we just need to hit the route we had defined above. Below, I'm sharing the body component of the demo app I created to illustrate this:

```jsx theme={null}
const Body = () => {
  const [formInput, setFormInput] = useState({ notif: '', email: '' });
  const [buttonClicked, setButtonClicked] = useState(false);

  const onSubmitHandler = async (e) => {
    e.preventDefault();
    const response = await fetch(
      'https://emaildigestbackend.onrender.com/api/v1/sending-email-digest',
      {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(formInput),
      }
    );
    console.log(response.data);
    setFormInput({ notif: '' });
  };

  const handleClick = () => {
    setButtonClicked(true);

    // Reset the button feedback after a certain duration
    setTimeout(() => {
      setButtonClicked(false);
    }, 100);
  };

  const onChangeHandler = (e) => {
    const value = e.target.name === 'email' ? e.target.value.trim() : e.target.value;

    setFormInput((prev) => ({
      ...prev,
      [e.target.name]: value,
    }));
  };
  return (
    <div>
      <h1>Email Digest Playground</h1>
      <p>
        Don't know how to? Start{' '}
        <a className="underline" href="https://docs.novu.co/platform/digest/">
          {' '}
          here
        </a>
      </p>
      <form onSubmit={onSubmitHandler}>
        <div>
          <div>
            <label htmlFor="email" className="w-48">
              Email:
            </label>
            <input
              placeholder="Your Email here"
              value={formInput.email}
              id="email"
              name="email"
              onChange={onChangeHandler}
            />
          </div>
          <div>
            <label htmlFor="notif">Notification:</label>
            <textarea
              placeholder="Enter the notification text"
              value={formInput.notif}
              id="notif"
              name="notif"
              onChange={onChangeHandler}
            />
          </div>
        </div>

        <button onClick={handleClick} type="submit">
          <BiRightArrowAlt className="text-2xl" />
        </button>
      </form>
    </div>
  );
};
```

We're hitting the backend route we had created earlier. The backend has been deployed on render as can be seen in this code snippet above.

Congratulations on following the guide up until this point. We can style our app a little using [some TailwindCSS](https://github.com/novuhq/digest-email-app/blob/main/frontend/src/app.css).

If you’ve done everything as recommended, you’ll end up with an app that looks like this:

<Frame>
  <img />
</Frame>

In this app, when we enter the email id, some text in the input box, and click send, the notification appears in the inbox after the delay specified above (when we’re creating the workflow).

This is how we add digest to email notifications!


# How to Add Digest to In-App Notifications
Source: https://v0.x-docs.novu.co/guides/add-digest-to-inapp-notifications

Leverage the digest functionality to send in-app notifications

## Introduction

In this guide, you’ll learn how to add digest notifications to a React app. But before exploring the actual code, let’s understand what a digest notification is and how it works.

You can find the entire code(frontend as well as backend) for this app [here](https://github.com/novuhq/digest-learning-app/tree/main).

### What is a Digest Notification?

Often times when you associate notifications with user activity, the end user can be bombarded with messages because of the nature of the activity. Take for example the case of commenting in the context of a social media app. If you were to send a notification to a user for every comment they receive, and they happen to receive 100 comments, it could lead to user fatigue since you would have to send 100 messages.

This is where digest notifications come into the picture!

A digest notification is a notification that consolidates information from several notifications into one and delivers that notification to the end user instead of several separate messages.

### How does Digest Notification Work?

Novu has a built-in digest engine that collects multiple trigger events, aggregates them into a single message and delivers it to the subscriber. You can use the digest engine by adding a `digest node` to your workflow in the workflow editor in the [Novu dashboard](https://web.novu.co/workflows?utm_campaign=docs-digestsinapp).

Let’s see it in action now!

## Add Digest Notification To An App

To get started with this, you need the following:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-digestsinapp) if you don’t have one yet.
* A working React development environment.

## Workflow setup in Novu

Once, you have these, follow the steps below:

1. Head over to the Novu Dashboard.
2. Click `Workflows` on the left sidebar of your Novu dashboard.
3. Click the `Create Workflow` button on the top right:

<Frame>
  <img />
</Frame>

Once you click the `create workflow` button, you’ll see a dropdown. Select `blank workflow` from the dropdown:

<Frame>
  <img />
</Frame>

You’ll now be taken to the workflow editor:

<Frame>
  <img />
</Frame>

Once here, you can add the channels you want to use for sending notifications and configure them. For this guide, we’ll use the `In-App` channel. You’ll also see the `Digest` action on the right sidebar.

<Note>
  Each node that is added below the digest node will only be triggered after the specified time interval
</Note>

For example, in our case, say we want the In-App notification to be sent after every 6 hours. Next, add the `digest` action below the `trigger node`, and add the `in-app` channel node below the `digest` node as shown below:

<Frame>
  <img />
</Frame>

The `digest` node allows you to set a specific time interval for when notifications should be sent:

<Frame>
  <img />
</Frame>

Once, you’ve configured it. Go ahead and configure the `in-app` channel as per your need:

<Frame>
  <img />
</Frame>

Here’s a brief explanation of all the options:

* **1-Preview**: This shows you a glimpse of what each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.

In our case, we’re going to use the following:

<Frame>
  <img />
</Frame>

Once you’re done configuring this to your liking, click on the `update` button on the top right.
It’ll automatically create a trigger code that you can use in your app. To get it, click on the `get snippet` button on the top right and copy it:

<Frame>
  <img />
</Frame>

Now, let’s see how to add Novu to our app!

# Add Novu to the Backend and Configure it

In your backend, install the novu package using the following code:

```bash theme={null}
npm install @novu/node
```

Now, create a route which you want to hit when called from the front end. In our demo app, this is the route:

```jsx theme={null}
import express from 'express';
import { getDigest } from '../controller/digest.js';

const router = express.Router();

router.post('/sending-digest', getDigest);

export default router;
```

Now, we need to write a controller function that will handle the logic for what is to be sent in the trigger function’s payload. In our case, this is the controller function:

```jsx theme={null}
import { sendDigest } from '../novu/novu.js';

export const getDigest = async (req, res) => {
  const { name } = req.body;
  try {
    await sendDigest(name);
    res.status(201).json({ message: 'success', name: name });
  } catch (error) {
    res.status(409).json({ message: error.message });
  }
};
```

To make it modular, we’ll keep the trigger code in a separate function in a separate file (`novu.js`, in our case) and the trigger function is getting called in the controller function above by the name `getDigest`.

If you’re following the guide, you’ve already copied the trigger function. But before we can add it to our app, we need one key thing - **Subscribers.**

Subscribers are entities to which the notifications are sent. You can see a list of subscribers in the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-digests-inapp) as well.

In our app, we’ll create a subscriber in Node.js as we’re writing our backend in Node.js, but we also have backend [SDKs](/sdks/introduction) (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin) to choose from. The recommended way to create a subscriber in NodeJS is as follows:

```jsx theme={null}
await novu.subscribers.identify('aa234u787', {
  firstName: 'digest subscriber',
});
```

Here, we’re creating a subscriber with the `subscriberID` of `aa234u787.` You can read more about subscribers [here](/subscribers/subscribers).

Back in our app, we can now add the trigger function:

```jsx theme={null}
import { Novu } from '@novu/node';

export const sendDigest = async (name) => {
  const novu = new Novu(process.env.NOVU_API_KEY);

  await novu.subscribers.identify('aa234u787', {
    firstName: 'digest subscriber',
  });

  await novu.trigger('digest-showcase', {
    to: {
      subscriberId: 'aa234u787',
    },
    payload: {
      name: name,
    },
  });
};
```

Now, we just need to hit the route defined above from the front end and add Novu to it.

# Add Novu’s Notification Center to the front end

In the front end, install the Novu notification centre package using the following command:

```bash theme={null}
npm install @novu/notification-center

```

Now, import and render the component in your app. The code to do so is as follows:

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
  IMessage,
} from '@novu/notification-center';

function Header() {
  function onNotificationClick(message: IMessage) {
    // your logic to handle the notification click
    if (message?.cta?.data?.url) {
window.location.href = message.cta.data.url;
    }
  }

  return (
    <NovuProvider subscriberId={'USER_ID'} applicationIdentifier={'APP_ID_FROM_ADMIN_PANEL'}>
      <PopoverNotificationCenter onNotificationClick={onNotificationClick}>
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}

```

You can, of course, modify things as you need. For example, in our app, this is what we’ve done in the header:

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
} from '@novu/notification-center';
import '../css/Header.css';

const Header = () => {
  function onNotificationClick(message) {
    // your logic to handle the notification click
    if (message?.cta?.data?.url) {
window.location.href = message.cta.data.url;
    }
  }
  return (
    <div className="bell">
      <div className="intro">
        <h1 className="title">Play with the digest engine!</h1>
        <p className="desc">
          Don't know how to? Start <a href="https://docs.novu.co/platform/digest/">here</a>.
        </p>
      </div>
      <div className="center">
        <NovuProvider
          subscriberId={'aa234u787'}
          applicationIdentifier={process.env.REACT_APP_YOUR_APP_ID_FROM_ADMIN_PANEL}
        >
          <PopoverNotificationCenter onNotificationClick={onNotificationClick}>
            {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
          </PopoverNotificationCenter>
        </NovuProvider>
      </div>
    </div>
  );
};

export default Header;
```

You’ll also need to plug in your `applicationIdentifier`. You can get your `application id` from the settings menu in the Novu dashboard.

Beyond this, we just need to call the API we had written above when the form is submitted with the data we want in the payload. The code to do so is as follows:

```jsx theme={null}
import { useState } from 'react';
import axios from 'axios';
import '../css/Body.css';

const Body = () => {
  const [name, setName] = useState('');

  const onSubmitHandler = async (e) => {
    e.preventDefault();
    const res = await axios.post('http://localhost:3000/api/v1/sending-digest', { name });
    setName('');
  };
  const onChangeHandler = (e) => {
    setName(e.target.value);
  };
  return (
    <form onSubmit={onSubmitHandler} className="form">
      <label for="noti-text" className="label">
        Enter notification text:
      </label>
      <input
        id="noti-text"
        placeholder="Will be sent as a digest message"
        type="text"
        onChange={onChangeHandler}
        value={name}
        className="text"
      />
      <button className="btn" type="submit">
        {' '}
        Send{' '}
      </button>
    </form>
  );
};

export default Body;
```

The app is done now!

Congratulations for following the guide up until this point. We can style our app a little using [some CSS](https://github.com/novuhq/digest-learning-app/blob/main/frontend/src/App.css).

If you’ve done everything as recommended, you’ll end up with an app that looks like this:

<Frame>
  <img />
</Frame>

In this app, when we enter some text in the input box and click send, the notification appears in the bell icon after the delay specified above (when we’re creating the workflow).

This is how we add digest to in-app notifications!


# Recipes
Source: https://v0.x-docs.novu.co/guides/cookbook/introduction



This cookbook contains recipes and code samples demonstrating how to accomplish everyday tasks with Novu in your application. Each code example uses our libraries and SDKs.

<Frame>
  <img />
</Frame>

## Fetch Subscriber Feed

A subscriber feed is a list of all In-App messages for a single subscriber. It's a continuous stream of messages displayed in a list that subscribers can scroll through on the frontend via the Notification Center.

It is a dynamic list with **seen** and **unseen** capabilities. Multiple feeds can exist for a subscriber.

<Warning>**Subscriber Feed** is very different from **Activity Feed**. The former is for In-App channels, while the latter is a list of every message and relevant metadata across all channels shown in your dashboard.</Warning>

The code sample below fetches the list of all In-App messages sent to a specific subscriber:

<CodeGroup>
  ```javascript Node.js  theme={null}
  const { data: inAppMessages } = await novu.subscribers.getNotificationsFeed('subscriberId', {
    page: 0,
    limit: 10,

    // it is of type string. By default all feeds messages are fetched
    feedIdentifier: 'Marketing',

    // seen and read filter of type boolean
    seen: true,
    read: true
  });
  ```
</CodeGroup>

## Fetch All Feeds

In-App messages are grouped in Feeds. There can be one or multiple feeds.

The code sample below fetches all the feeds that have been created and exist in the In-App steps:

<CodeGroup>
  ```javascript Node.js  theme={null}
  const { data: feedsData } = await novu.feeds.get();
  ```
</CodeGroup>

## Delete a Message From a Feed

A message is a content sent to a single subscriber over a single channel. Some messages are simple, like SMS, while others have more features and capabilities, such as Email, Chat, In-App.

A single message can be deleted from a Feed. The code sample below shows how to do it:

<CodeGroup>
  ```javascript Node.js  theme={null}
  await novu.messages.deleteById('messageId');
  ```
</CodeGroup>

## Fetch all Messages Sent To All Subscribers

You can retrieve all messages sent to all subscribers. There are a couple of filters you can apply to fetch these messages.

* channel: fetches all messages that were sent via a specific channel, e.g Email, Sms, Push, In-App
* subscriberId: fetches all messages sent to a specific subscriber
* transactionIds: fetches all messages via transaction ids.

<CodeGroup>
  ```javascript Node.js  theme={null}
  import { ChannelTypeEnum } from '@novu/node';

  // All fields are optional
  const listMessagesOptions = {
    // pagination options
    page: 0,
    limit: 20,

    /**
     *  Filter options
     */
    // use ChannelTypeEnum.PUSH for push, ChannelTypeEnum.IN_APP for in-app,
    channel: ChannelTypeEnum.EMAIL, // only email type messages will be fetched
    subscriberId: '6444105141ffb0919496dfcb',
    transactionIds: ['644-41051-41ffb0-919496-dfcb'],
  };

  const { data: messagesData } = await novu.messages.list(listMessagesOptions);
  ```
</CodeGroup>

## Mark an In-App Message as Read/Seen

You can mark an In-App message as read/seen. Messages from other channels: **Email**, **Push**, **Chat**, **Sms** can't be marked as read/seen.

<CodeGroup>
  ```javascript Node.js  theme={null}
  const { data: markMessageAsRead } = await novu.subscribers.markMessageRead(
    'subscriberId',
    'messageId'
  );

  const { data: markMessageAsSeen } = await novu.subscribers.markMessageSeen(
    'subscriberId',
    'messageId'
  );
  ```
</CodeGroup>

## Mark an In-App Message as Read/Unread/Seen/Unseen

You can mark an In-App message as read/unread/seen/unseen. Messages from other channels: **Email**, **Push**, **Chat**, **Sms** can't be marked as read/unread/seen/unseen.

<CodeGroup>
  ```javascript Node.js  theme={null}
  const { data: markMessageAs } = await novu.subscribers.markMessageAs(
    'subscriberId',
    'messageId',
    { seen: true, read: false }
  );
  ```
</CodeGroup>

## Mark all In-App Messages as Read/Unread/Seen/Unseen

You can mark all In-App messages as read/unread/seen/unseen.

Messages from other channels: **Email**, **Push**, **Chat**, **Sms** can't be marked as read/unread/seen/unseen.

<CodeGroup>
  ```javascript Node.js  theme={null}
  import { MarkMessagesAsEnum } from "@novu/node"

  const { data: markAllInAppMessages } = await novu.subscribers.markAllMessagesAs(
     'subscriberId',

     // can be filtered with feed identifiers
     feedIdentifier: ['Marketing', 'Product']

     // MarkMessageAsEnum.READ => It will mark all messages as read
     // MarkMessageAsEnum.SEEN => It will mark all messages as seen
     // MarkMessageAsEnum.UNREAD => It will mark all messages as unread
     // MarkMessageAsEnum.UNSEEN => It will mark all messages as unseen
     markAs: MarkMessageAsEnum.Read
  );
  ```
</CodeGroup>

## Send Slack Notifications

You can send notifications to Slack Channels via Novu like so:

```javascript Node.js theme={null}
import {
  Novu,
  ChatProviderIdEnum
} from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

// Identify Subscriber
await novu.subscribers.identify('<SUBSCRIBER_ID>', {
  firstName: 'newSubForSlackChat',
});

// Set credentials for the Subscriber
await novu.subscribers.setCredentials('<SUBSCRIBER_ID>', ChatProviderIdEnum.Slack, {
  webhookUrl: "<WEBHOOK_URL>",
});

// Trigger slack notification
await novu.trigger('slack', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>'
  },
  payload: {
    chatMsg: '<INSERT_MESSAGE_CONTENT>'
  }
});
```

where `chatMsg` is a payload variable in the workflow editor.

Follow the [full guide](/guides/slack-guide) on how to send Slack notifications using Novu.


# Demo apps
Source: https://v0.x-docs.novu.co/guides/demos/introduction

Experience the power of Novu for triggering, digesting, and receiving notifications via different channels

### 1. Email, In-App Notification & Authentication

<Frame>
  <img />
</Frame>

<CardGroup>
  <Card title="Github" icon="github" href="https://github.com/novuhq/examples/tree/main/vue-nextjs-trigger-inapp-notifications">
    Find the source code here!
  </Card>

  <Card title="Demo" icon="play" href="https://novu-notifications-vue3.vercel.app/">
    Try it yourself first-hand!
  </Card>
</CardGroup>

### 2. Headless Notification Center

<Frame>
  <img />
</Frame>

<CardGroup>
  <Card title="Github" icon="github" href="https://github.com/novuhq/novu-headless-demo-app">
    Find the source code here!
  </Card>

  <Card title="Demo" icon="play" href="https://headlessdemo.vercel.app/">
    Try it yourself first-hand!
  </Card>
</CardGroup>

### 3. Notification Center

<Frame>
  <img />
</Frame>

<CardGroup>
  <Card title="Github" icon="github" href="https://github.com/novuhq/notification-center-demo">
    Find the source code here!
  </Card>

  <Card title="Demo" icon="play" href="https://notification-center-demo.vercel.app/">
    Try it yourself first-hand!
  </Card>
</CardGroup>

### 4. Email Digest Engine

<Frame>
  <img />
</Frame>

<CardGroup>
  <Card title="Github" icon="github" href="https://github.com/novuhq/digest-email-app">
    Find the source code here!
  </Card>

  <Card title="Demo" icon="play" href="https://emaildigest.vercel.app/">
    Try it yourself first-hand!
  </Card>
</CardGroup>

### 5. InApp Digest Engine

<Frame>
  <img />
</Frame>

<CardGroup>
  <Card title="Github" icon="github" href="https://github.com/novuhq/digest-learning-app">
    Find the source code here!
  </Card>

  <Card title="Demo" icon="play" href="https://digestplayground.vercel.app/">
    Try it yourself first-hand!
  </Card>
</CardGroup>


# How to use Novu to send notifications to a channel in a Discord server
Source: https://v0.x-docs.novu.co/guides/discord-guide

Learn to send Discord notifications swiftly with Novu

# Introduction

In this guide, you'll learn how to use Novu to send notifications to any channel in a Discord server. But before coding anything up, we just need to go over a couple of setup steps.
The corresponding docs for this guide are available on our [docs](https://docs.novu.co/channels-and-providers/chat/discord).
<Note>The entire code for this app is available on our [GitHub](https://github.com/novuhq/discord-chat-app).</Note>

So let's begin!

# Set up Discord

Setting up Discord is fairly straightforward. You just need the `webhook Url`. It is pretty simple and can be done in the following easy steps:

1. Go to the channel you want to add the webhook to (you need to be an admin of the discord server).

<Frame>
  <img />
</Frame>

2. Right-click the channel and select “Edit Channel”.

<Frame>
  <img />
</Frame>

3. Select Integrations -> Webhooks -> Create Webhook

<Frame>
  <img />
</Frame>

4. Edit the Bot name to your liking, copy the webhook URL and store it somewhere. We'll need it in the future.

<Frame>
  <img />
</Frame>

# Set up Novu

In this part, we'll set up a workflow that will be triggered when we send a notification. Workflows are like blueprints and hold the entire flow of notifications. You can read more about them on our [docs](https://docs.novu.co/workflows/notification-workflows). To set up a notification workflow for our app, follow these steps:

1. Make sure that you've set the Discord Integration as active from the [Novu Integrations Store](https://web.novu.co/integrations?utm_campaign=docs-discordnotifications).

<Frame>
  <img />
</Frame>

2. Goto the [Novu Web Dashboard](https://web.novu.co/workflows?utm_campaign=docs-discordnotifications).
3. Click on the 'Add a workflow' button and select 'Blank workflow' from the dropdown.

<Frame>
  <img />
</Frame>

4. Once there, give your workflow a name and drag and drop the 'chat' option below the 'workflow trigger' step.

<Frame>
  <img />
</Frame>

5. You can also add variables in the Workflow Editor. For example, here I've added 'chatMsg' as a variable as I'll be sending data using it.

<Frame>
  <img />
</Frame>

<Info>Whatever is placed inside double braces is a variable.</Info>
6\. Click the 'Get Snippet' button, copy the trigger code and keep it somewhere. We'll need this to trigger this workflow.

<Frame>
  <img />
</Frame>

Now, we've completed all the setup required and can move to coding!

# Create the backend

The backend for this app is quite simple. Simply install the Novu package:

```bash theme={null}
npm install @novu/node

```

Now, create a route that you'll hit when called from the front end. For our demo app, this is the route I've created:

```jsx theme={null}
import express from "express";
import { chatController } from "../controller/chat.js";

const router = express.Router();

router.post("/sendChat",chatController);

export default router;
```

Now, we need a controller function to handle what is to be sent in the trigger's function payload. Here's the controller I wrote:

```jsx theme={null}
import { chat } from "../novu/novu.js"

export const chatController = async (req, res) => {
    const { chatMsg } = req.body;
    try {
        await chat(chatMsg);
        res.status(201).json({ message: "Message sent successfully" });
    } catch (error) {
        console.log("notifController error:", error);
        res.status(500).json({ message: error.message })
    }
}
```

<Info>Notice how we're expecting 'chatMsg' in our payload. This is why we added it as a variable in the workflow created earlier.</Info>
To make it modular, we’ll keep the trigger code in a separate function in a separate file, `novu.js`, in our case, which is as follows:

```jsx theme={null}
import { Novu, ChatProviderIdEnum } from '@novu/node';

export const chat = async (chatMsg) => {
    try {
        const novu = new Novu(process.env.YOUR_NOVU_API_KEY_HERE);

        await novu.subscribers.identify(process.env.SUB_ID, {
            firstName: 'newSubForDiscordChat',
        });

        await novu.subscribers.setCredentials(process.env.SUB_ID, ChatProviderIdEnum.Discord, {
            webhookUrl: process.env.WEBHOOK_URL
        });

    } catch (error) {
        console.log(error);
    }
}
```

Add the trigger code you'd copied earlier:

```jsx theme={null}
import { Novu } from '@novu/node'; 

const novu = new Novu('<API_KEY>');

novu.trigger('chat-with-discord', {
    to: {
      subscriberId: '<REPLACE_WITH_DATA>'
    },
    payload: {
      chatMsg: '<REPLACE_WITH_DATA>'
    }
  });
```

Our final trigger code should look something like this:

```jsx theme={null}
import { Novu, ChatProviderIdEnum } from '@novu/node';

export const chat = async (chatMsg) => {
    try {
        const novu = new Novu(process.env.YOUR_NOVU_API_KEY_HERE);

        await novu.subscribers.identify(process.env.SUB_ID, {
            firstName: 'newSubForDiscordChat',
        });

        await novu.subscribers.setCredentials(process.env.SUB_ID, ChatProviderIdEnum.Discord, {
            webhookUrl: process.env.WEBHOOK_URL
        });

        await novu.trigger('chat-with-discord', {
            to: {
                subscriberId: process.env.SUB_ID
            },
            payload: {
                chatMsg: chatMsg
            }
        });
    } catch (error) {
        console.log(error);
    }
}
```

<Info>We're keeping all the sensitive data in a `.env` file to avoid hardcoding as a good practice</Info>

In this code snippet above, we're first initializing a new instance of Novu, then using it to 'identify' or [create](https://docs.novu.co/subscribers/subscribers#create-a-subscriber) a [subscriber](https://docs.novu.co/subscribers/subscribers).
<Info>The 'identify' method tries to find a subscriber with the given info. If it can't find any such subscriber, it creates a new subscriber with the supplied info.</Info>
After creating the subscriber, it runs the trigger code for the workflow we had created.

# Front end set up

For our demonstration purposes, the front-end is pretty basic. All we have to do is have an input field to take the notification text in and send the payload. The front-end code for this demo app is available on our [Github repo](https://github.com/novuhq/discord-chat-app/tree/main/frontend).
And here's our app in all its glory!

<Frame>
  <img />
</Frame>

This is how we send Discord notifications using Novu!


# How to send push notifications to Flutter apps (Android & iOS) with FCM using Novu
Source: https://v0.x-docs.novu.co/guides/fcm-flutter-novu/how-to-send-push-notifications-to-flutter-apps-with-fcm-using-Novu

Learn how to integrate Firebase Cloud Messaging with Novu and send notifications to Flutter apps

## Prerequisites

To complete this guide, you will need the following:

* [Apple Developer](https://developer.apple.com/) membership (to obtain the required permissions to send push notifications).
* A machine running MacOS to work on building the Flutter app for iOS devices.
* [Firebase](https://firebase.google.com/) account
* [Novu](https://web.novu.co/?utm_campaign=docs-gs-guides-fcm-flutter) account.
* [Android Studio](https://developer.android.com/studio/install) configured with Dart and Flutter plugins.
* [Xcode](https://developer.apple.com/xcode/) installed on your machine.

Check out the [Flutter app code for this guide on GitHub](https://github.com/novuhq/flutter-fcm-novu).

## Set up and Create a Flutter App

If you have an existing Flutter App, you can skip this step.

If you are creating a brand new Flutter app, please follow this [guide](https://firebase.google.com/codelabs/firebase-fcm-flutter#0).

## Set up Firebase and FlutterFire

Please follow this [guide to set up a Firebase project and integrate Firebase Cloud Messaging in your Flutter app](https://firebase.google.com/codelabs/firebase-fcm-flutter#2).

## Set Up Apple Integration

Please follow this [guide to ensure that everything is set up on your iOS device](https://firebase.flutter.dev/docs/messaging/apple-integration) to receive messages.

There is an optional section about allowing **Notification Images**. Follow the steps to install and activate the notification service extension. We'll need it later in this guide to display images as part of the push notifications from FCM.

## Set Up FCM Notification Permission & Registration Token

We'll add code to initialize Firebase and ask the user's permission to receive notifications.

Open up the `lib/main.dart` file in your Flutter app and replace everything with the code below:

```dart theme={null}
import 'package:flutter/foundation.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:flutter/material.dart';
import 'firebase_options.dart';
import 'package:firebase_messaging/firebase_messaging.dart'; // FlutterFire's Firebase Cloud Messaging plugin

// Add Stream controller
import 'package:rxdart/rxdart.dart';

// for passing messages from event handler to the UI
final _messageStreamController = BehaviorSubject<RemoteMessage>();

@pragma('vm:entry-point')
Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
  // If you're going to use other Firebase services in the background, such as Firestore,
  // make sure you call `initializeApp` before using other Firebase services.
  await Firebase.initializeApp();

  print("Handling a background message: ${message.messageId}");
  print('Message data: ${message.data}');
  print('Message notification: ${message.notification?.title}');
  print('Message notification: ${message.notification?.body}');

}

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );

  // Request permission
  final messaging = FirebaseMessaging.instance;

  // Web/iOS app users need to grant permission to receive messages
  final settings = await messaging.requestPermission(
    alert: true,
    announcement: false,
    badge: true,
    carPlay: false,
    criticalAlert: false,
    provisional: false,
    sound: true,
  );

  if (kDebugMode) {
    print('Permission granted: ${settings.authorizationStatus}');
  }

  // Register with FCM
  // It requests a registration token for sending messages to users from your App server or other trusted server environment.
  String? token = await messaging.getToken();

  if (kDebugMode) {
    print('Registration Token=$token');
  }

  // Set up foreground message handler
  FirebaseMessaging.onMessage.listen((RemoteMessage message) {
    if (kDebugMode) {
      print('Handling a foreground message: ${message.messageId}');
      print('Message data: ${message.data}');
      print('Message notification: ${message.notification?.title}');
      print('Message notification: ${message.notification?.body}');
    }

    _messageStreamController.sink.add(message);
  });

  // Set up background message handler
  FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);

  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const MyHomePage(title: 'Flutter Demo Home Page'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({Key? key, required this.title}) : super(key: key);

  final String title;

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  String _lastMessage = "";

  _MyHomePageState() {
    _messageStreamController.listen((message) {
      setState(() {
        if (message.notification != null) {
          _lastMessage = 'Received a notification message:'
              '\nTitle=${message.notification?.title},'
              '\nBody=${message.notification?.body},'
              '\nData=${message.data}';
        } else {
          _lastMessage = 'Received a data message: ${message.data}';
        }
      });
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            Text('Last message from Firebase Messaging:',
                style: Theme.of(context).textTheme.titleLarge),
            Text(_lastMessage, style: Theme.of(context).textTheme.bodyLarge),
          ],
        ),
      ),
    );
  }
}
```

*lib/main.dart*

There are 4 sections to pay attention to:

<Steps>
  <Step title="The Request permission code block">
    This shows the notification permission prompt to the user when the user interacts with the app for the first time. If the user allows it, then we can get a token.

    ```dart theme={null}
    // Request permission
    final messaging = FirebaseMessaging.instance;

    // Web/iOS app users need to grant permission to receive messages
    final settings = await messaging.requestPermission(
      alert: true,
      announcement: false,
      badge: true,
      carPlay: false,
      criticalAlert: false,
      provisional: false,
      sound: true,
    );
    ```
  </Step>

  <Step title="Registering and obtaining the FCM token for the device">
    A device's token is needed for the specific device to receive messages. The `getToken()` returns the registration token for the app instance on the device.

    ```dart theme={null}
      String? token = await messaging.getToken();

      if (kDebugMode) {
        print('Registration Token=$token');
      }
    ```
  </Step>

  <Step title="The foreground message handler">
    This handler listens to when a push notification is sent from FCM to the device. If the app is in the foreground, then it prints out the notification title, body, messageId, and data properties to the console.

    ```dart theme={null}
      FirebaseMessaging.onMessage.listen((RemoteMessage message) {
        if (kDebugMode) {
          print('Handling a foreground message: ${message.messageId}');
          print('Message data: ${message.data}');
          print('Message notification: ${message.notification?.title}');
          print('Message notification: ${message.notification?.body}');
        }

        _messageStreamController.sink.add(message);
      });
    ```
  </Step>

  <Step title="The background message handler">
    This handler listens to when a push notification is sent from FCM to the device. If the app is in the background, then it prints out the notification title, body, messageId, and data properties to the console.

    ```dart theme={null}
      ...
      @pragma('vm:entry-point')
      Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
        // If you're going to use other Firebase services in the background, such as Firestore,
        // make sure you call `initializeApp` before using other Firebase services.
        await Firebase.initializeApp();

        print("Handling a background message: ${message.messageId}");
        print('Message data: ${message.data}');
        print('Message notification: ${message.notification?.title}');
        print('Message notification: ${message.notification?.body}');

      }
      ...


      FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);
    ```
  </Step>
</Steps>

Now, run the Flutter app. Your device should be connected to your machine to enable the app to run on it.

<Frame>
  <img />
</Frame>

<br />

<Frame>
  <img />
</Frame>

<br />

<Frame>
  <img />
</Frame>

## Cloud Message Test

In your Firebase project, navigate to `Engage` section and click on `Messaging`.

<Frame>
  <img />
</Frame>

Click on `Create your first campaign` and select `Firebase Notification messages`.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Enter the `Notification title` and the `Nabigateotification text`, and click on `Send test message`.

<Frame>
  <img />
</Frame>

We must copy and paste this FCM registration token to confirm our device. You can find it logged as shown earlier in our editor.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Click on 'Test'.

<Frame>
  <img />
</Frame>

You should see the notification on your device!

<Frame>
  <img />
</Frame>

## Sign Up on Novu

Let's use Novu to fire push notifications via FCM. First, sign up on [Novu Cloud](https://web.novu.co)?utm\_campaign=docs-gs-guides-fc-flutter.

<Frame>
  <img />
</Frame>

Next, immediately configure FCM as a Push channel provider.

<Frame>
  <img />
</Frame>

You can also do this by heading straight to the `Integrations Store`. Click on `Add a provider`.

## Connect  FCM as a Push Channel provider

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

You only need to configure FCM with Novu with the Firebase Service Accounts private key.

To acquire the account key JSON file for your service account, follow this instructions:

1. Select your project. Click the gear icon on the top of the sidebar.
2. Head to project settings.
3. Navigate to the `Service accounts` tab.
4. Click `Generate new private key`, then confirm by clicking `Generate key`.
5. Click `Generate key` to download the JSON file.
6. Once the file is on your machine, paste the entire JSON file content in the `Service Account` field of the FCM provider in the Integration store on Novu’s web dashboard.

Make sure your service account key JSON content contains these fields:

```JSON theme={null}

{
  "type": "service_account",
  "project_id": "PROJECT_ID",
  "private_key_id": "PRIVATE_KEY_ID",
  "private_key": "PRIVATE_KEY",
  "client_email": "FIREBASE_ADMIN_SDK_EMAIL",
  "client_id": "CLIENT_ID",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "CLIENT_X509_CERT_URL"
}

```

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Create a Notification Workflow

In Novu, creating a workflow means establishing a blueprint for sending notifications within your app. This unified structure ties together email, in-app messages, SMS, push notifications, and chat into **one entity**.

Each workflow has a unique name and identifier and includes customized content for various channels, using `{{handlebars}}` variables for personalization.

This ensures consistent platform notifications and allows dynamic adjustments for individual subscribers, scenarios, and use cases.

<Steps>
  <Step title="Navigate to 'Workflows' tab and click on 'Blank Workflow'">
    <Frame>
      <img />
    </Frame>

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Add (Drag & Drop) the Push channel node to the workflow">
    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Click on the node, and start to modify the content. Add a title and content. Once you are done, click on 'Update'">
    <Frame>
      <img />
    </Frame>
  </Step>
</Steps>

We need to fire notifications to subscribers. So, let's create a subscriber!

## Create A Subscriber & Update Credentials

A subscriber is essentially the recipient of the notifications sent through Novu's system. When you create a subscriber, you're setting up the necessary information for Novu to send targeted notifications to that individual.

You can see the list of subscribers in the `Subscribers` section of the Novu dashboard.

<Frame>
  <img />
</Frame>

<Steps>
  <Step title="Create a subscriber">
    ```JSON theme={null}

    curl --location 'https://api.novu.co/v1/subscribers' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <YOUR_API_KEY>' \
    --data-raw '{
    "subscriberId": "584349343",
    "firstName": "Flutter",
    "lastName": "Boy",
    "email": "flutterboy@gmail.com",
    }'

    ```

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Grab the FCM device token from your Editor log">
    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Add Device Tokens to Subscriber by Updating Subscriber Credentials">
    <Note> Subscriber can have multiple device tokens </Note>

    Here, you can locate the Provider\_Identifier.

    <Frame>
      <img />
    </Frame>

    ```JSON theme={null}

      curl --request PUT \
          --url https://api.novu.co/v1/subscribers/{subscriber_id}/credentials \
          --header 'Content-Type: application/json' \
          --header 'Authorization: ApiKey <YOUR_API_KEY>' \
          --data '{
              "credentials":{
                "deviceTokens": ["<insert-fcm-token>"]
            },
            "integrationIdentifier":"<Provider_Identifier>",
            "providerId":"fcm"
      }'

    ```

    *Update the Subscriber Credentials by adding the device tokens to the subscriber*
  </Step>
</Steps>

## Sending a Push Notification to a Device(Android/iOS) with Novu

To send a notification with Novu, you are actually triggering a notification workflow.
You have the ability to test the trigger using the Novu UI or by calling Novu's API.

**Trigger a workflow via the API**

Insert the `trigger identifier` as the name in the API request below:

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "<REPLACE_WITH_DATA>"
         },
         "payload": {}
       }'

```

**Trigger a workflow via the Novu Dashboard**

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

**Receive Triggered Push Workflow on Device**

<Frame>
  <img />
</Frame>

## Dynamic Content

When we were creating the first workflow, we "Hardcoded" the content of the notification.

Now, we will determine the content when calling the API.

1. In the workflow, we should change the values of the `title` and the `body` to `{{title}}` and `{{body}}`.
   That way, we could insert values through the payload of the API call.

<Frame>
  <img />
</Frame>

2. Add a `payload` object to the API call.

Insert the `trigger identifier` as the name in the API request below:

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "This title was set via the Payload",
           "body": "This body was set via the Payload"
         },
       }'

```

<Frame>
  <img />
</Frame>

## Handling Data Type Messages

With FCM, you can send `Notification` and `Data` messages. We have handled sending notification messages. Let's handle data messages.

Data messages contain user-defined custom key-value pairs. The information is encapsulated in the `data` key. The app can do whatever it pleases with the data once it's received by the device.

**Via the Trigger API call**

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "This title was set via the Payload",
           "body": "This body was set via the Payload"
         },
         "overrides": {
          "fcm": {
            "data": {
              "subscription_status": "active",
              "renewed_by": "bisola"
            }
          }
         }
       }'

```

<Frame>
  <img />
</Frame>

## Sound of a notification

You can use the name of a sound file in your app's main bundle or in the Library/Sounds folder of your app's container directory.

Specify the string "default" to play the system sound. Use it for regular notifications. For critical alerts, use the sound dictionary instead.

The code below works for iOS devices:

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "Notification With Sound",
           "body": "Hello World from Novu"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "payload": {
                 "aps": {
                   "sound": "default" // configure sound to the notification
                 }
               }
             }
           }
         }
       }'

```

For Android devices, use the following:

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "Notification With Sound",
           "body": "Hello World from Novu"
         },
         "overrides": {
           "fcm": {
             "android": {
               "notification": {
                 "defaultSound": true // This uses the Android framework's default sound for the notification.
               }
             }
           }
         }
       }'

```

## Priority for notification

If you omit this header, APNs (iOS) set the notification priority to `10`.

* Specify `10` to send the notification immediately.
* Specify `5` to send the notification based on power considerations on the user’s device.
* Specify `1` to prioritize the device’s power considerations over all other factors for delivery and prevent awakening the device.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "apns-priority: 5",
           "body": "Novu's API"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "headers": {
				          "apns-priority":"5" //priority for notifications
			          },
               "payload": {
                 "aps": {}
               },
               "fcm_options": {}
             }
           }
         }
       }'

```

For Android devices, specify `high` or `normal` for the priority of the notification message.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "priority",
           "body": "Novu's API"
         },
         "overrides": {
           "fcm": {
             "android": {
               "priority": "high"
             }
           }
         }
       }'

```

## Sending Push Notification With Image

Up to this point, your notifications have all contained only text. But if you’ve received many notifications, you know that notifications can have rich content, such as images. It’d be great if your notifications showed users a nice image related to their content. Once again, Firebase makes this super simple.

To show an image in push notifications, you’ll need to create a ***Notification Service Extension***. We handled it earlier in this guide during the Apple setup.

For reiteration, follow [this guide](https://firebase.flutter.dev/docs/messaging/apple-integration#advanced-optional-allowing-notification-images) to ensure it is properly set up for iOS devices.

When making the API call, we should include:

* "mutable-content": 1 inside the “aps” object.
* "image" in "fcm\_options" object,
* URL address of the image.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "This is a notification with an image",
           "body": "Check this out"
         },
         "overrides": {
           "fcm": {
             "apns": {
                "payload": {
                  "aps": {
                    "mutable-content": 1
                  }
                },
                "fcm_options": {
                  "image": "https://www.planetware.com/wpimages/2020/02/france-in-pictures-beautiful-places-to-photograph-eiffel-tower.jpg"
                  }
            }
          }
        }
    }'
```

## Additional resources

* [Notifications Usage - Flutter Fire](https://firebase.flutter.dev/docs/messaging/notifications)


# How to batch product notifications via code
Source: https://v0.x-docs.novu.co/guides/framework-guides/digest

Leverage Novu's Digest Engine to batch product notifications

# Introduction

Learn how to use Novu’s Digest engine to batch notifications. In this guide, you’ll learn how to aggregate multiple messages and send them off as one notification. Follow these steps:

## Getting started

Integrating Novu’s code-first workflow with React.Email for your Next.js application can be done in three steps

1. Create a fully-featured Novu NextJS app with the command below:

```bash theme={null}
npx create-novu-app
```

1. Once this installation is complete, simply `cd` into the directory and start your app using the `npm run dev` command.

Now, we’re all set to send digested notifications but before we do, let’s look at what it is and how it works:

## Digest engine and how it works

Novu’s Digest Engine is designed to consolidate multiple trigger events into a single cohesive message before delivering it to the subscriber. This functionality is essential for managing notification overload and ensuring that users receive meaningful, aggregated updates rather than being bombarded with numerous individual notifications. Here’s how it works:

1. **Event Accumulation**: The digest engine collects multiple trigger events based on a unique `subscriberId` to be delivered as one message.
2. **Batching Events**: The engine batches these events within a specified time interval. This interval can be configured in units of seconds, minutes, hours, days, weeks, or months.
3. **Delivery**: After the accumulation period, the batched events are sent out as a single notification. This consolidated message reduces the frequency of notifications and provides the user with a summary of all relevant events.

## How to digest in a code-first workflow:

1. Write a workflow and add a digest node to it:

```tsx theme={null}
import { Client } from "@novu/framework";

export const client = new Client({
  apiKey: '<YOUR_NOVU_API_KEY>',
  /**
   * Enable this flag only during local development
   */
  strictAuthentication: process.env.NODE_ENV !== "development",
});

export const digestWorkflow = workflow('novu-digest',
  
  async ({ step, payload }) => {
  
    // Add Digest Node
    const digestResult = await step.digest('email-digest', async () => ({
      unit: 'seconds',
      amount: 30,
    }));

    // Send a welcome email
    await step.email('send-email', () => {
      const resObj = {
        subject: `Welcome to Novu`,
        body: (digestResult.events.map((event) => event.payload.text).join('\n')),
      }
      return resObj
    });
  },
  {
    payloadSchema: {
      properties: {
        email: { type: 'string' },
        text: { type: 'string', default: 'Sumit' },
      },
      required: ['text'],
    },
  }
);

```

<Info>
  💡 In the digest node above, you can change the digest duration by setting a value to the key `amount` and changing the value of `unit` to seconds, minutes, hours, days, weeks, or months
</Info>

2. Here’s a simple client-side app with a handler function attached to the `submit` event:

```tsx theme={null}
"use client"
import React, { useState } from "react";

export default function Home() {

  const [email, setEmail] = useState('')
  const [text, setText] = useState('')

  const onClickHandler = async (e: React.FormEvent<HTMLFormElement>) => {
    try {
      e.preventDefault();
      await fetch("/api/users", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          email: email,
          text: text,
        }),
      });

      // console.log('working fine');
    } catch (error) {
      console.error('Error:', error);
    }
  };
  return (
    <main style={{ height: '100vh', display: 'flex', justifyContent: 'center', alignItems: 'center' }}>
      <form onSubmit={(e) => onClickHandler(e)}>
        <input
          placeholder="Enter email id"
          onChange={(e) => setEmail(e.target.value)}
          style={{
            // Add your CSS-in-JS styles here
            padding: '0.5rem',
            marginBottom: '1rem',
            borderRadius: '0.25rem',
            border: '1px solid #ccc',
            width: '100%',
            boxSizing: 'border-box',
          }}
        />
        <input
          placeholder="Enter the notification text"
          onChange={(e) => setText(e.target.value)}
          style={{
            // Add your CSS-in-JS styles here
            padding: '0.5rem',
            marginBottom: '1rem',
            borderRadius: '0.25rem',
            border: '1px solid #ccc',
            width: '100%',
            boxSizing: 'border-box',
          }}
        />
        <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'center' }}>

          <button
            style={{
              // Add your CSS-in-JS styles here
              padding: '0.5rem 1rem',
              backgroundColor: '#4CAF50',
              color: 'white',
              border: 'none',
              borderRadius: '0.25rem',
              cursor: 'pointer',
            }}
          >
            Submit
          </button>
        </div>
      </form>
    </main>
  );
}

```

3. And the corresponding route that it hits once the event fires:

```tsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<YOUR_NOVU_API_KEY>');

export async function POST(request: Request) {
    const res = await request.json();

    await novu.trigger('novu-digest', {
        to: {
            subscriberId: 'novu-sub-digest',
        },
        payload: {
            email: res.email,
            text: res.text
        },
    });

    console.log('triggered')
    return Response.json({ success: true });
}

```

That’s it!

That’s how simple it is to use Novu’s Digest Engine. Digesting notifications enhances the user experience by providing comprehensive summaries, making it easier for users to stay informed about important updates in a concise manner, without straining users with too many notifications. We have got a thorough guide on digesting notifications [in our docs](https://docs.novu.co/guides/add-digest-to-email-notifications) that you can check out as well.


# How to send notifications with Next.js and MJML
Source: https://v0.x-docs.novu.co/guides/framework-guides/framework-mjml

Leverage MJML package to send email notifications

# Introduction

This guide will walk you through how to send notifications with MJML and Novu. You can check out the code for a [sample demo app](https://github.com/novuhq/framework-mjml).

## Pre-requisites

* A Novu account
* Node installed on your machine
* A working NextJS development environment

## Get started with Novu Framework

[Novu Framework](https://docs.novu.co/framework/quickstart) is a "notifications as code" approach that enables developers to define workflows as functions and integrate them with their preferred libraries for email, SMS, and chat generation.

1. To get started with Novu Framework, just run this command in your terminal, it’ll scaffold a new NextJS project with Novu Framework and we’ll be ready to roll!

```jsx theme={null}
npx create-novu-app --api-key=<YOUR_API_KEY>

```

2. Once you execute this command, you’ll be asked to give your project a name. I’ll keep the default `my-novu-app` but you can choose your own.

<Frame>
  <img />
</Frame>

3. You’ll then be asked if you want to use React-email or not. Since, we’ll be using MJML, I’m choosing the default 'No' option.

<Frame>
  <img />
</Frame>

4. After this step, all the dependencies will be installed and you will be able to start using Novu Framework.

<Frame>
  <img />
</Frame>

5. Once this installation is complete, simply cd into the directory and start your app using the `npm run dev` command, and your app will be served on `localhost:4000`

<Note>
  Make sure that the port 4000 isn’t already being used!
</Note>

You’ll now have a NextJS app running on `http://localhost:4000` and you can make changes to your app as you see fit. Let’s now move to the meaty stuff - using Novu Framework in a NextJS app and the magic of Dev Studio.

## Echo Dev Studio

The Echo Dev Studio is a companion app to the Echo Client SDK. Its goal is to provide a local environment that lives near your code.

To launch the dev studio locally you can run: `npx novu-labs@latest echo`. The Dev Studio will be started by default on port `2022`, and accessible via: `http://localhost:2022`

<Frame>
  <img />
</Frame>

Here’s how the Dev Studio looks on the first run:

<Frame>
  <img />
</Frame>

You’ll notice that it asks for an `Echo endpoint` at the bottom. Novu Echo requires a single HTTP endpoint (`/api/echo` or similar) to be exposed by your application. This endpoint is used to receive events from our Worker Engine. We have more on Novu endpoint [in our docs.](https://docs.novu.co/framework/concepts/endpoint)

<Note>
  You can view the Echo Endpoint as a webhook endpoint that Novu will call when it needs to retrieve contextual information for a given subscriber and notification.
</Note>

Just enter the full URL of your Echo Endpoint. In our case, it is `http://localhost:4000/api/echo`

<Frame>
  <img />
</Frame>

Once you do, you’ll see a green checkmark alongside the URL input box and a green `connected` highlight at the top right corner.

## Installing and configuring MJML

Integrating MJML with Novu in our NextJS app is quite straightforward, with just one small caveat. Following are the steps to get it installed and configured:

1. Simply run the following command to install it like any other npm package:

```bash theme={null}
npm i mjml
```

<Warning>
  Once installed, you need to keep in mind that, MJML doesn’t play very nice with newer web technologies such as Next.js that we’re using today. In order to overcome some hurdles, we need to use the `require` statement when importing MJML in our files, such as when defining the template.
</Warning>

2. To write an email template, you can look over some of the examples in the MJML documentation to get inspiration from. In our case, this is the template:

```jsx theme={null}
// notice the use of require statement here:
const mjml2html = require("mjml")

export const mjmlTemplate = (inputs: Inputs) => {
    const { text, buttonText, imageUrl, buttonUrl } = inputs;
    return (mjml2html(`
    <mjml>
    <mj-body background-color="#d7dde5">
      <mj-section full-width="full-width">
        <mj-column width="66.66666666666666%" vertical-align="middle">
          <mj-text align="left" font-size="11px" padding-bottom="0px" padding-top="0"><span style="font-size: 11px">${text}</span></mj-text>
        </mj-column>
        <mj-column width="33.33333333333333%" vertical-align="middle">
          <mj-text align="right" font-size="11px" padding-bottom="0px" padding-top="0"><span style="font-size: 11px"><a href="${buttonUrl}" style="text-decoration: none; color: inherit;">OnePage</a></span></mj-text>
        </mj-column>
      </mj-section>
      <mj-section background-color="#ffffff" full-width="full-width">
        <mj-column width="33.33333333333333%" vertical-align="middle">
          <mj-image src="http://191n.mj.am/img/191n/1t/hx.png" alt="OnePage" padding-bottom="0px" padding-top="10px"></mj-image>
        </mj-column>
        <mj-column width="66.66666666666666%" vertical-align="middle">
          <mj-text align="center" padding-bottom="0px" padding-top="10px"><a href="${buttonUrl}" style="text-decoration: none; color: inherit;">Home</a>&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;<a href="${buttonUrl}" style="text-decoration: none; color: inherit;">Features</a>&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;
            <a href="${buttonUrl}" style="text-decoration: none; color: inherit;">Portfolio</a>
          </mj-text>
        </mj-column>
      </mj-section>
      <mj-section background-url="${imageUrl}" vertical-align="middle" background-size="cover" full-width="full-width" background-repeat="no-repeat">
        <mj-column width="100%" vertical-align="middle">
          <mj-text align="center" font-size="14px" color="#45474e" padding-bottom="10px" padding-top="45px"><span style="font-size: 30px; line-height: 30px;">More than an email template</span><br /><br />Only on <span style="color: #e85034">Mailjet</span> template builder</mj-text>
          <mj-button align="center" background-color="#e85034" color="#fff" border-radius="24px" href="${buttonUrl}" font-family="Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif" padding-bottom="45px" padding-top="10px">${buttonText}</mj-button>
        </mj-column>
      </mj-section>
      <mj-section background-color="#ffffff" vertical-align="top" full-width="full-width">
        <mj-column vertical-align="top" width="33.33333333333333%">
          <mj-image src="http://191n.mj.am/img/191n/1t/hs.png" alt="" width="50px"></mj-image>
          <mj-text align="center" color="#9da3a3" font-size="11px" padding-bottom="30px"><span style="font-size: 14px; color: #e85034">Best audience</span><br /><br />Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque eleifend sagittis nunc, et fermentum est ullamcorper dignissim.</mj-text>
        </mj-column>
        <mj-column vertical-align="top" width="33.33333333333333%">
          <mj-image src="http://191n.mj.am/img/191n/1t/hm.png" alt="" width="50px"></mj-image>
          <mj-text align="center" color="#9da3a3" font-size="11px" padding-bottom="30px"><span style="font-size: 14px; color: #e85034">Higher rates</span><br /><br />Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque eleifend sagittis nunc, et fermentum est ullamcorper dignissim.</mj-text>
        </mj-column>
        <mj-column vertical-align="top" width="33.33333333333333%">
          <mj-image src="http://191n.mj.am/img/191n/1t/hl.png" alt="" width="50px"></mj-image>
          <mj-text align="center" color="#9da3a3" font-size="11px" padding-bottom="30px" padding-top="3px"><span style="font-size: 14px; color: #e85034">24/7 Support</span><br /><br />Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque eleifend sagittis nunc, et fermentum est ullamcorper dignissim.</mj-text>
        </mj-column>
      </mj-section>
      <mj-section background-color="#e85034" vertical-align="middle" full-width="full-width">
        <mj-column width="100%" vertical-align="middle">
          <mj-text align="center" color="#ffffff" font-size="18px" padding-bottom="10px">Why choose us?</mj-text>
          <mj-divider border-color="#fff" border-style="solid" border-width="1px" padding-left="100px" padding-right="100px" padding-bottom="20px" padding-top="20px"></mj-divider>
          <mj-text align="center" color="#f8d5d1" font-size="11px" padding-bottom="25px">Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris. Lorem ipsum dolor sit amet, consectetur adipiscing
            elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris.</mj-text>
        </mj-column>
      </mj-section>
      <mj-section vertical-align="middle" background-color="#ffffff" full-width="full-width">
        <mj-column width="50%" vertical-align="middle">
          <mj-image src="http://191n.mj.am/img/191n/1t/h2.jpg" alt="" padding-bottom="20px" padding-top="20px"></mj-image>
        </mj-column>
        <mj-column width="50%" vertical-align="middle">
          <mj-text align="left" color="#9da3a3" font-size="11px" padding-bottom="25px" padding-top="25px"><span style="font-weight: bold; font-size: 14px; color: #45474e">Great newsletter for the best company out there</span><br /><br />Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna
            aliqua. Ut enim ad minim veniam.</mj-text>
          <mj-button align="left" background-color="#e85034" color="#fff" border-radius="24px" font-size="11px" href="${buttonUrl}" font-family="Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif" padding-bottom="45px" padding-top="10px">READ MORE</mj-button>
        </mj-column>
      </mj-section>
      <mj-section full-width="full-width">
        <mj-column width="100%" vertical-align="middle">
          <mj-text align="center" font-size="11px" padding-bottom="0px" padding-top="0px">
          <p style="font-size: 11px">
          Please contact us if you have any questions. 
          </mj-text>
        </mj-column>
      </mj-section>
    </mj-body>
  </mjml>
    `));
}
```

3. And as final step, we need to define the workflow that uses the template defined above.

```jsx theme={null}
import { Client, workflow } from "@novu/framework";
import { mjmlTemplate } from "./mjml";

export const client = new Client({
  apiKey: process.env.NOVU_API_KEY,
  strictAuthentication: process.env.NODE_ENV !== "development",
});

export const emailWorkflow = workflow('mjml-email-workflow', async ({ payload, step }) => {
  await step.email('send-email', async (inputs) => {
    return {
      subject: `Welcome to MJML with Novu Framework, ${payload.text}!`,
      body: mjmlTemplate(inputs).html,
    };
  }, {
    inputSchema: {
      type: 'object',
      properties: {
        text: { type: 'string', default: 'Welcome to our service' },
        imageUrl: { type: 'string', default: 'https://picsum.photos/id/11/2000/300' },
        buttonText: { type: 'string', default: 'Sign up' },
        buttonUrl: { type: 'string', default: 'https://novu.co' },
      },
      additionalProperties: false,
    } as const
  });
}, {
  payloadSchema: {
    properties: {
      text: { type: 'string', default: 'Sumit' },
    },
    additionalProperties: false,
  }
});
```

Once you do this, you’ll see this workflow, the steps in the workflow, step inputs, payload variables and the rendered view of this workflow on the Echo Dev Studio:

<Frame>
  <img />
</Frame>

Here, from the Dev Studio, you or your peers can change things like the text of a button, toggle visibility of a button, static text content etc and have it synced with the cloud with the `Sync to Cloud` button.

### Payload vs Step Inputs

Notice that in the Echo dev studio above, we’ve used payload as well as step inputs. Here’s how you can decide if you need either or both:

| Payload                                                                                                                               | Step Inputs                                                                                                                                                                             |
| ------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| is used for dynamic content that changes from one notification to another based on events occurring in your system.                   | are used for static elements or predefined options that non-technical team members can modify without altering the codebase.                                                            |
| is controlled by developers and passed dynamically through the novu.trigger method.                                                   | are defined by developers but aremeant to be utilized and modified by non-technical peers.                                                                                              |
| Payload examples include User ID, Post ID, Comment, Order ID, 2FA token, etc., which are likely to change with each notification.     | Step Inputs examples include the text of a button, whether a section should be shown, static text content, etc., which are generally static but configurable elements.                  |
| Payload modifications are made in the code by developers at the time of triggering a notification.                                    | Step Inputs can be modified directly in the UI, offering a no-code solution for non-technical team members to make changes.                                                             |
| Payload data is passed during the novu.trigger method and is part of the dynamic data handling process within notification workflows. | Step Inputs are predefined in the workflow configuration and can be adjusted through the Echo Dev Studio, affecting how notifications are rendered without changing the workflow logic. |

## Syncing with the cloud, with the click of a button

Once done with the workflow, now we need to sync it to the cloud. Fortunately, Novu Framework makes it a breeze to sync changes from the local machine to the cloud and it all happens with a click of a button.

To enable our cloud environment to talk to your local Bridge instance, you need to supply an Bridge endpoint URL. This sets up a communication channel between our cloud environment and your local instance. To allow Novu to communicate with your local machine a tunnel will need to be generated.

The `create-novu-app` command sets up `localtunnel` for you. Running the `npm run dev` script in the project launches both the Bridge application and the tunnel solution. The tunnel URL shows up in the console output.

You can also use a tool like `ngrok`:

```bash theme={null}
// using ngrok 
ngrok http http://localhost:<YOUR_EDGE_PORT>      
```

In our case, the app is running on port 4000 so we’ll use:

```bash theme={null}
ngrok http http://localhost:4000
```

This will create a tunnel and you’ll see something like this in the terminal:

<Frame>
  <img />
</Frame>

Remember, the exact URL (`/api/novu` or similar) you expose in your application for handling Novu Framework requests is what you'd consider the `Bridge URL`.

This URL would be the endpoint within your application's domain where Novu's Worker Engine sends requests to fetch notification content or subscriber details dynamically. In our case, it is this: [https://faec-2409-40f2-3c-3b57-400e-a7f7-1fc0-1e5.ngrok-free.app/api/echo](https://faec-2409-40f2-3c-3b57-400e-a7f7-1fc0-1e5.ngrok-free.app/api/echo)
So, we’ll enter this Bridge URL:

<Frame>
  <img />
</Frame>

And create diff:

<Frame>
  <img />
</Frame>

## Testing our workflow

Once you’ve synced your changes in the previous step, you’ll see a notification that says ‘Sync complete’ and you can now go to Novu Cloud using the ‘Test your workflows’ link and trigger a notification.

<Frame>
  <img />
</Frame>

You’ll see the workflow you’ve created has a blue lightning bolt icon. That icon signifies that the corresponding workflow has been created with Novu Framework:

<Frame>
  <img />
</Frame>

Simply open the workflow and you can send a test email from there.

<Note>
  Make sure that all the expected payload variables and step inputs are being sent in their respective fields!
</Note>

<Frame>
  <img />
</Frame>

This is the workflow test email in my inbox:

<Frame>
  <img />
</Frame>

Once tested, you can simply have this workflow triggered whenever you want. For instance, a typical use case is to have a workflow triggered when an event occurs. To replicate it, I’ve attached a handler function that triggers this workflow when the `submit` event fires:

Here’s a simple replication of the stipulated scenario:

```jsx theme={null}
'use client';

import { useState } from 'react';

export default function Home() {
  const [loading, setLoading] = useState(false);
  const [text, setText] = useState('')
  const [email, setEmail] = useState('')


  const triggerWorkflow = async () => {
    setLoading(true);
    const response = await fetch('/api/users', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        text: text,
        email: email
      }),
    });
    const result = await response.json();
    setLoading(false);
    console.log(result);
  };
  return (
    <div>
      <h1>MJML Email with Novu Framework</h1>
      <input placeholder='Enter customer name' onChange={e => setText(e.target.value)} value={text} />
      <input placeholder='Enter customer email' onChange={e => setEmail(e.target.value)} value={email} />
      <button onClick={triggerWorkflow} disabled={loading}>
        {loading ? 'Sending...' : 'Send Email'}
      </button>
    </div>
  );
}

```

And the corresponding route it hits:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<Your Novu API Key>');

export async function POST(request: Request) {
  const res = await request.json();

  await novu.trigger('mjml-email-workflow', {
    to: {
      subscriberId: 'novu-sub-two',
      email: res.email
    },
    payload: {
      text: res.text,
    },
  });

  console.log('triggered')
  return Response.json({ success: true });
}
```

So there you go!

This is how you create workflows using Novu Framework and deploy your changes seamlessly to the Novu cloud. You can check out the code for a [sample demo app](https://github.com/novuhq/framework-mjml).

Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows.

Don’t forget to share your workflows with us and as always, hit us up on Discord with any questions you might have!


# How to send notifications with Nuxt.js and Vuemail
Source: https://v0.x-docs.novu.co/guides/framework-guides/framework-nuxt-vuemail

Learn how to send email notifications with Nuxt.js, Vuemail and Novu

This guide assumes you know what [a notification workflow](https://docs.novu.co/workflows/notification-workflows) is and why you need it. It also assumes you are aware of [Nuxt](https://nuxt.com/) and [VueEmail](https://vuemail.net/).
Fantastic. Now that we are all on the same page let’s proceed.

Novu recently released a new way of baking notification workflows into your apps via code, and it’s huge! Let me walk you through it.

It’s called Novu Framework and you can learn more about it by visiting the related [documentation](https://docs.novu.co/framework/quickstart). You might also benefit from reading this excellent [Code-First Approach to Managing Notification Workflows](https://novu.co/blog/a-code-first-approach-to-managing-notification-workflows/) article.

If you prefer to clone the repository from GitHub and get your hands dirty, we aren’t going to stop you. You can find it [here](https://github.com/novuhq/novu-framework-nuxt-vue-email-example).

Still here? Good, I wrote this guide for you!

## Getting Started

## 1. Initialize **New Nuxt Project**

We will follow the [official installation guide from Nuxt](https://nuxt.com/docs/getting-started/installation), open your terminal / IDE, and run the following command:

```jsx theme={null}
npx nuxi@latest init <project-name>
```

## 2. **Integrate Novu Framework Into Our App (Notification Workflow)**

1. We will install the `@novu/framework` package in the root of our Nuxt app directory by running the following command:

```jsx theme={null}
npm install @novu/framework
```

2. We must provide an API endpoint for the [Novu Dev Studio](https://docs.novu.co/framework/concepts/studio) to fetch our notification workflow. (Don’t worry; we guide you through all the steps.) Navigate to your app's `app/server` directory and create a new directory named `api`.

```jsx theme={null}
cd app/server

mkdir api
```

Create a file within the `app/server/api` directory and name it `novu.ts`.  Copy and paste the code snippet below:

```jsx theme={null}
// app/server/api/novu.ts
import { serve } from "@novu/framework/nuxt";
import { client, myWorkflow } from "../novu/workflows";

export default defineEventHandler(serve({ client: client, workflows: [myWorkflow] }));
```

3. Now, let's create the instance where we will build and maintain our notification workflow:

Navigate to your `app/server` directory and create another directory named `novu`.

```jsx theme={null}
cd app/server

mkdir novu
```

Create a file within the `app/server/novu` directory and name it `workflows.ts`.  Copy and paste the code snippet below:

```jsx theme={null}
// app/server/novu/workflows.ts
// This workflow already renders vue email template.

import { config } from '@vue-email/compiler'
import { Client, workflow } from '@novu/framework';

const vueEmail = config('templates', {
  verbose: false,
  options: {
  },
})

export const client = new Client({
  /**
   * Disable this flag only during local development
   * For production this should be true
   */
  strictAuthentication: process.env.NODE_ENV !== "development"
});

export const myWorkflow = workflow('hello-world', async ({ step, payload }) => {
    await step.email(
        'send-email',
        async () => {
            const template = await vueEmail.render('sample-email.vue', {
                props: payload,
            });
            return {
                subject: `You have a new invitation from: ${payload.username}.`,
                body: template.html,
            }
        });
},
    {
        payloadSchema: {
            // Always `object`
            type: 'object',
            // Specify the properties to validate. Supports deep nesting.
            properties: {
                        username: { type: "string" },
                        invitedByEmail: { type: "string" },
                        inviteLink: { type: "string" },
                        inviteFromIp: { type: "string" },
                        inviteFromLocation: { type: "string" }
            },
            // Used to enforce full type strictness, with no rogue properties.
            additionalProperties: false,
            // The `as const` is important to let Typescript know that this
            // type won't change, enabling strong typing on `inputs` via type
            // inference of the provided JSON Schema.
        } as const,
    },
);
```

We haven’t finished the guide yet but have everything to build a notification workflow.

Below, We can see a “plain” Client instance and shaping your desired workflow.

```jsx theme={null}
// app/server/novu/workflows.ts
// This is Client instance concept - not a working instance!

import { Client, workflow } from '@novu/framework';

export const client = new Client({
  /**
   * Disable this flag only during local development
   * For production this should be true
   */
  strictAuthentication: process.env.NODE_ENV !== "development"
});

export const myWorkflow = workflow(
	'<WORKFLOW_NAME>', // The Workflow name. Must be unique across your Bridge application.
	// Workflow resolver, the entry-point for your Workflow steps
	async ({
		// Helper function to declare your Workflow Steps.
		step,
		// Workflow Trigger payload
		payload,
	}) => {
	// ...your Workflow Steps
}, {
	// JSON Schema for validation and type-safety. Zod, and others coming soon.
	// https://json-schema.org/draft-07/json-schema-release-notes

	// The schema for the Workflow payload passed dynamically via Novu Trigger API
	// Defaults to an empty schema.
	payloadSchema: { properties: { name: { type: 'string' }}},
	// The schema for the Workflow inputs passed statically via Novu Web
	// Defaults to an empty schema.
	inputSchema: { properties: { brandColor: { type: 'string' }}},
});
```

We can:

* Select a name for our workflow.
* Declare [Workflow Steps](https://docs.novu.co/framework/steps/introduction) as we see fit for our use case
* Configure what could be passed in the payload of the Workflow Trigger ([payloadSchema](https://docs.novu.co/framework/concepts/inputs))
* Configure what inputs could be passed statically via Novu Web ([inputSchema](https://docs.novu.co/framework/concepts/inputs))

Note: You can create and manage as many workflows as you wish within `app/server/novu/workflows.ts`; make sure to provide each workflow with a unique name.

## 3. Adding Vuemail in our notification workflow

1. We will install the `vue-email` package in the root of our Nuxt app directory by running the following command:

```jsx theme={null}
npm install vue-email
```

2. We will create one more directory in the root of our directory and name it `templates`. That is where our vue-email templates will be stored.

```c theme={null}
mkdir templates
```

3. In the `app/templates` directory, we will create a file for our first vue-email template and name it `sample-email.vue`.

[You can find examples of Vue email templates here.](https://vuemail.net/playground)

```jsx theme={null}
// app/templates/sample-email.vue

<script setup lang="ts">
import { defineProps, withDefaults } from 'vue'

interface Props {
  invitedByUsername?: string
  teamName?: string
  username?: string
  invitedByEmail?: string
  inviteLink?: string
  inviteFromIp?: string
  inviteFromLocation?: string
  showFootnote?: boolean;
  components: string[] | null
}

const baseUrl = "https://react-email-demo-bdj5iju9r-resend.vercel.app";

const props = withDefaults(defineProps<Props>(), {
  teamName: 'Cleaning',
  username: 'John Doe',
  invitedByEmail: 'anpch@example.com',
  inviteLink: 'https://acme.com/projects/accept/foo',
  inviteFromIp: '172.0.0.1',
  inviteFromLocation: 'San Francisco, CA',
  showFootnote: true,
  components: null
})

const previewText = `Join ${props.invitedByUsername} on Vercel`
</script>

<template>
  <ETailwind>
    <EHtml>
      <EHead />
      <EPreview>{{ previewText }}</EPreview>
      <EBody class="bg-white my-auto mx-auto font-sans">
        <EContainer class="border border-solid border-[#eaeaea] p-[20px] md:p-7 rounded my-[40px] mx-auto max-w-[465px]">
          <div v-for="item in components || []">
            <EButton v-if="item === 'button'" px="20" py="12" class="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center" :href="inviteLink"> Accept </EButton>
            <EText v-if="item === 'text'" class="text-black text-[14px] leading-[24px]"> Hello {{ username }}, </EText>
            <EHr v-if="item === 'divider'" class="border border-solid border-[#eaeaea] my-[26px] mx-0 w-full" />
          </div>
          <ESection class="mt-[32px]">
            <EImg :src="`${baseUrl}/static/vercel-logo.png`" width="40" height="37" alt="Vercel" class="my-0 mx-auto" />
          </ESection>
          <Hello />
          <EHeading class="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
            New Project <strong>{{ teamName }}</strong> available
          </EHeading>
          <EText class="text-black text-[14px] leading-[24px]"> Hello {{ username }}, </EText>
          <EText class="text-black text-[14px] leading-[24px]">
            <strong>{{invitedByUsername}}</strong> (
            <ELink :href="`mailto:${invitedByEmail}`" class="text-blue-600 no-underline">
              {{ invitedByEmail }}
            </ELink>
            ) has invited you to the <strong>{{ teamName }}</strong> project on <strong>Acme</strong>.
          </EText>
          <ESection>
            <ERow>
              <EColumn align="right">
                <EImg class="rounded-full" :src="`${baseUrl}/static/vercel-user.png`" width="64" height="64" />
              </EColumn>
              <EColumn align="center">
                <EImg :src="`${baseUrl}/static/vercel-arrow.png`" width="12" height="9" alt="invited you to" />
              </EColumn>
              <EColumn align="left">
                <EImg class="rounded-full" :src="`${baseUrl}/static/vercel-team.png`" width="64" height="64" />
              </EColumn>
            </ERow>
          </ESection>
          <ESection class="text-center mt-[32px] mb-[32px]">
            <EButton px="20" py="12" class="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center" :href="inviteLink"> Accept </EButton>
            <EButton px="20" py="12" class="rounded text-[12px] font-semibold no-underline text-center" :href="inviteLink"> Decline </EButton>

          </ESection>
          <EText class="text-black text-[14px] leading-[24px]">
            or copy and paste this URL into your browser:
            <ELink :href="inviteLink" class="text-blue-600 no-underline">
              {{ inviteLink }}
            </ELink>
          </EText>

          <EHr class="border border-solid border-[#eaeaea] my-[26px] mx-0 w-full" />
          <EText v-if="showFootnote" class="text-[#666666] text-[12px] leading-[24px]">
            This invitation was intended for
            <span class="text-black">{{ username }} </span>.This invite was sent from <span class="text-black">{{ inviteFromIp }}</span> located in
            <span class="text-black">{{ inviteFromLocation }}</span
            >. If you were not expecting this invitation, you can ignore this email. If you are concerned about your account's safety, please reply to this email to get in touch
            with us.
          </EText>

        </EContainer>
      </EBody>
    </EHtml>
  </ETailwind>
</template>
```

## 4. Launching The Dev Studio

Now that we have everything in our notification workflow configured along with the vue-email template we will use, it’s time to see a visual representation of what we have built.

1. If you haven’t run the development environment for your Nuxt app, now is the time.

   ```jsx theme={null}
   npm run dev
   ```

2. Do you remember that we exposed an Bridge API endpoint in our app for Dev Studio to catch? This is where it happens.

   Run the following command in a separate terminal:

   ```jsx theme={null}
   npx novu-labs@latest echo
   ```

   If you’ve followed this guide, you should see this:

   <Frame>
     <img />
   </Frame>

   Here is where our exact API endpoint goes. If our application runs on a different port, we should change the URL manually to point Dev Studio in the right direction.

   <Frame>
     <img />
   </Frame>

   Also, if we have configured everything correctly, we should see that Dev Studio sees our workflow identifier (Workflow unique name).

   <Frame>
     <img />
   </Frame>

3. Click the “View Workflow” button in the Dev Studio to see the workflow.

   We should see the following:

   <Frame>
     <img />
   </Frame>

Click on the workflow step node called `send-email`. We should see a preview of our email template and the `Step Input` and `Payload` variables we have configured in the workflow schemas.

<Frame>
  <img />
</Frame>

4. This is the time to adjust the email template, step input schema, or define the properties we anticipate in the payload. We have a live representation of everything. You can add more steps like In-App, SMS, and chat.

## 5. Syncing our workflow to Novu Cloud

Having completed crafting, designing, and modifying our notification workflow to suit our requirements, we're ready to push it to Novu Cloud. There, it will handle the heavy lifting and seamlessly execute all the steps we've configured whenever we trigger the workflow.

1. Click on the `Sync to Cloud` button on the top right.

   <Frame>
     <img />
   </Frame>

2. We will need to create a local tunnel that the Novu Cloud environment can reach for local experimentation purposes.

   <Frame>
     <img />
   </Frame>

   On a separate terminal, run the following command:

   ```jsx theme={null}
   // Change to the port where the app is currently running

   npx localtunnel --port 3000
   ```

   We should get something like:

   ```jsx theme={null}
   your url is: https://famous-pumas-clap.loca.lt
   ```

   <Frame>
     <img />
   </Frame>

3. Click the `Create Diff` button. To push (merge) the workflow code to the cloud, an API Key from our Novu account should be added to our Framework Client instance.

   <Frame>
     <img />
   </Frame>

   Let’s navigate to `../app/server/novu/workflows.ts` file and add our Novu API Key.

```jsx theme={null}
// app/server/novu/workflows.ts
// This workflow already renders vue email template.

import { config } from '@vue-email/compiler'
import { Client, workflow } from '@novu/framework';

const vueEmail = config('templates', {
  verbose: false,
  options: {
  },
})

export const client = new Client({
  apiKey: process.env.NOVU_API_KEY, // <<-- Your Novu API KEY
  /**
   * Disable this flag only during local development
   * For production this should be true
   */
  strictAuthentication: process.env.NODE_ENV !== "development"
});

export const myWorkflow = workflow('hello-world', async ({ step, payload }) => {
    await step.email(
        'send-email',
        async () => {
            const template = await vueEmail.render('sample-email.vue', {
                props: payload,
            });
            return {
                subject: `You have a new invitation from: ${payload.username}.`,
                body: template.html,
            }
        });
},
    {
        payloadSchema: {
            // Always `object`
            type: 'object',
            // Specify the properties to validate. Supports deep nesting.
            properties: {
                        username: { type: "string" },
                        invitedByEmail: { type: "string" },
                        inviteLink: { type: "string" },
                        inviteFromIp: { type: "string" },
                        inviteFromLocation: { type: "string" }
            },
            // Used to enforce full type strictness, with no rogue properties.
            additionalProperties: false,
            // The `as const` is important to let Typescript know that this
            // type won't change, enabling strong typing on `inputs` via type
            // inference of the provided JSON Schema.
        } as const,
    },
);
```

We will now click the `Create Diff` button again.

<Frame>
  <img />
</Frame>

This is where you can review all the changes made to the workflow. Once you have verified that everything is in order, go ahead and click the `Deploy Changes` button.

<Frame>
  <img />
</Frame>

## 6. Testing Our Notification Workflow

There are many ways to test and [trigger our workflow](https://docs.novu.co/api-reference/events/trigger-event), but we'll make a `cURL` API call to Novu Cloud from our terminal in this guide.

If we don't have any subscribers or users in our database or within our Novu Cloud organization, we'll send the test to ourselves for simplicity.

* In the `subscriberId` key, input a random number or even our email address (as long as we do not try to assign the same ID key to another subscriber, we should be good).
* For the `email` key, we will need to insert a valid email address so we can actually receive the email.

<Info>**Note:** Learn more about the structure of [subscriber properties](https://docs.novu.co/subscribers/subscribers).</Info>

We can leave the payload empty or add properties aligned with the `payloadSchema` we established in the workflow definition.

```jsx theme={null}

curl -X POST https://api.novu.co/v1/events/trigger \
  -H "Authorization: ApiKey <NOVU_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "hello-world",
    "to": {
      "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      "email": "john@doemail.com",
    },
    "payload": {
        "username": "Jane Doe",
		    "invitedByEmail": "Jane@doemail.com",
		    "inviteLink": "https://acme.com/projects/accept/foo",
		    "inviteFromIp": "172.0.0.1",
		    "inviteFromLocation": "New York, DC"
    }
  }'

```

Now, let’s check our email inbox.

* No longer limited by UI notification steps and rigidity.
* No longer limited by notification content editors and systems. The more, the merrier!
* Now an IFTTT (If-This-Then-That) pro engineer!

Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows. Have fun, and share your use case on Discord with us!


# How to send notifications with Next.js and React email
Source: https://v0.x-docs.novu.co/guides/framework-guides/framework-react-email

Leverage the React email package to send email notifications

# Introduction

In this guide, you’ll learn how to send email notifications using the React email package. But before we jump into it, let's first take a look at the prerequisites!

## Pre-requisites

* A Novu account
* Node installed on your machine
* A working NextJS development environment

## Get started with Novu Framework

[Novu Framework](https://docs.novu.co/framework/quickstart) is a "notifications as code" approach that enables developers to define workflows as functions and integrate them with their preferred libraries for email, SMS, and chat generation.

1. To get started with Novu Framework, just run this command in your terminal, it’ll scaffold a new NextJS project with Novu Framework and we’ll be ready to roll!

```jsx theme={null}
npx create-novu-app --api-key=<YOUR_API_KEY>
```

2. Once you execute this command, you’ll be asked to give your project a name. I’ll keep the default `my-novu-app` but you can choose your own.

<Frame>
  <img />
</Frame>

3. You’ll then be asked if you want to use React-email or not. You can choose to install it at this step itself or proceed with No and then install it later. I’m choosing the default No option.

<Frame>
  <img />
</Frame>

4. After this step, all the dependencies will be installed and you will be able to start using Novu Framework.

<Frame>
  <img />
</Frame>

5. Once this installation is complete, simply cd into the directory and start your app using the `npm run dev` command, and your app will be served on `localhost:4000`

<Note>
  Make sure that the port 4000 isn’t already being used!
</Note>

You’ll now have a NextJS app running on `http://localhost:4000` and you can make changes to your app as you see fit. Let’s now move to the meaty stuff - using Novu Framework in a NextJS app and the magic of Dev Studio.

## Echo Dev Studio

The Echo Dev Studio is a companion app to the Echo Client SDK. Its goal is to provide a local environment that lives near your code.

To launch the dev studio locally you can run: `npx novu-labs@latest echo`. The Dev Studio will be started by default on port `2022`, and accessible via: `http://localhost:2022`

<Frame>
  <img />
</Frame>

Here’s how the Dev Studio looks on the first run:

<Frame>
  <img />
</Frame>

You’ll notice that it asks for an `Bridge endpoint` at the bottom. Novu Framework requires a single HTTP endpoint (`/api/novu` or similar) to be exposed by your application. This endpoint is used to receive events from our Worker Engine. We have more on Bridge endpoint [in our docs.](https://docs.novu.co/framework/concepts/endpoint)

<Note>
  You can view the Bridge Endpoint as a webhook endpoint that Novu will call when it needs to retrieve contextual information for a given subscriber and notification.
</Note>

Just enter the full URL of your Bridge Endpoint. In our case, it is `http://localhost:4000/api/echo`

<Frame>
  <img />
</Frame>

Once you do, you’ll see a green checkmark alongside the URL input box and a green `connected` highlight at the top right corner.

## Installing and configuring React Email

<Note>
  If you opted for installing React Email in our CLI set-up process, you can skip installing it again.
</Note>

Integrating React Email with Novu in our NextJS app is quite straightforward. Following are the steps to get it installed and configured:

1. Simply run the following command to install it like any other npm package:

```jsx theme={null}
  npm i @react-email/components react-email
```

Once installed, proceed to write an email template in the next step

2. To write an email template, you can look over some of the examples in the [React Email documentation](https://react.email/examples) to get inspiration. In our case, this is the template:

```jsx theme={null}
import {
  Body,
  Button,
  Container,
  Column,
  Head,
  Hr,
  Html,
  Img,
  Link,
  render,
  Row,
  Section,
  Text,
  Tailwind,
} from "@react-email/components";
import * as React from "react";

interface VercelInviteUserEmailProps {
  username?: string;
  userImage?: string;
  invitedByUsername?: string;
  invitedByEmail?: string;
  teamName?: string;
  teamImage?: string;
  inviteLink?: string;
  inviteFromIp?: string;
  showJoinButton?: boolean;
  inviteFromLocation?: string;
  buttonText?: string
}

const baseUrl = process.env.VERCEL_URL
  ? `https://${process.env.VERCEL_URL}`
  : "";

export const VercelInviteUserEmail = ({
  username,
  userImage,
  invitedByUsername,
  invitedByEmail,
  teamName,
  teamImage,
  inviteLink,
  inviteFromIp,
  inviteFromLocation,
  showJoinButton,
  buttonText
}: VercelInviteUserEmailProps) => {

  return (
    <Html>
      <Head />
      <Tailwind>
        <Body className="bg-white my-auto mx-auto font-sans px-2">
          <Container className="border border-solid border-[#eaeaea] rounded my-[40px] mx-auto p-[20px] max-w-[465px]">
            <Section className="mt-[32px]">
              <Img
                src={`https://react-email-demo-ndjnn09xj-resend.vercel.app/static/vercel-logo.png`}
                width="40"
                height="37"
                alt="Vercel"
                className="my-0 mx-auto"
              />
            </Section>
            <Text className="text-black text-[14px] leading-[24px]">
              Hello {username},
            </Text>
            <Text className="text-black text-[14px] leading-[24px]">
              <strong>{invitedByUsername}</strong> (
              <Link
                href={`mailto:${invitedByEmail}`}
                className="text-blue-600 no-underline"
              >
                {invitedByEmail}
              </Link>
              ) has invited you to the <strong>{teamName}</strong> team on{" "}
              <strong>Vercel</strong>.
            </Text>
            <Section>
              <Row>
                <Column align="right">
                  <Img
                    className="rounded-full"
                    src={userImage}
                    width="64"
                    height="64"
                  />
                </Column>
                <Column align="center">
                  <Img
                    src={`https://react-email-demo-ndjnn09xj-resend.vercel.app/static/vercel-arrow.png`}
                    width="12"
                    height="9"
                    alt="invited you to"
                  />
                </Column>
                <Column align="left">
                  <Img
                    className="rounded-full"
                    src={teamImage}
                    width="64"
                    height="64"
                  />
                </Column>
              </Row>
            </Section>
            {showJoinButton && (
              <Section className="text-center mt-[32px] mb-[32px]">
                <Button
                  className="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center px-5 py-3"
                  href={inviteLink}
                >
                  {buttonText}
                </Button>
              </Section>
            )}
            <Text className="text-black text-[14px] leading-[24px]">
              or copy and paste this URL into your browser:{" "}
              <Link href={inviteLink} className="text-blue-600 no-underline">
                {inviteLink}
              </Link>
            </Text>
            <Hr className="border border-solid border-[#eaeaea] my-[26px] mx-0 w-full" />
            <Text className="text-[#666666] text-[12px] leading-[24px]">
              This invitation was intended for{" "}
              <span className="text-black">{username}</span>. This invite was
              sent from <span className="text-black">{inviteFromIp}</span>{" "}
              located in{" "}
              <span className="text-black">{inviteFromLocation}</span>. If you
              were not expecting this invitation, you can ignore this email. If
              you are concerned about your account's safety, please reply to
              this email to get in touch with us.
            </Text>
          </Container>
        </Body>
      </Tailwind>
    </Html>
  );
};

VercelInviteUserEmail.PreviewProps = {
  username: "alanturing",
  userImage: `${baseUrl}/static/vercel-user.png`,
  invitedByUsername: "Alan",
  invitedByEmail: "alan.turing@example.com",
  teamName: "Enigma",
  teamImage: `${baseUrl}/static/vercel-team.png`,
  inviteLink: "https://vercel.com/teams/invite/foo",
  inviteFromIp: "204.13.186.218",
  inviteFromLocation: "São Paulo, Brazil",
} as VercelInviteUserEmailProps;

export default VercelInviteUserEmail;

export function renderReactEmail(input: any, payload: any) {
  return render(<VercelInviteUserEmail {...input}{...payload} />);

}
```

3. And as final step, we need to define the workflow that uses the template defined above.

```jsx theme={null}
export const newSignup = workflow('new-signup', async ({ step, payload }) => {
  // Send a welcome email
  await step.email('send-email', async (inputs) => {
    return {
      subject: `Welcome to Novu, ${payload.username}`,
      body: renderReactEmail(inputs, payload),
    };
  }, {
    inputSchema: {
      type: "object",
      properties: {
        showJoinButton: { type: "boolean", default: true },
        buttonText: { type: "string", default: "Join the team" },
        userImage: {
          type: "string",
          default: "https://react-email-demo-bdj5iju9r-resend.vercel.app/static/vercel-user.png",
          format: "uri",
        },
        invitedByUsername: { type: "string", default: "Alan" },
        invitedByEmail: {
          type: "string",
          default: "alan.turing@example.com",
          format: "email",
        },
        teamName: { type: "string", default: "Team Awesome" },
        teamImage: {
          type: "string",
          default: "https://react-email-demo-bdj5iju9r-resend.vercel.app/static/vercel-team.png",
          format: "uri",
        },
        inviteLink: {
          type: "string",
          default: "https://vercel.com/teams/invite/foo",
          format: "uri",
        },
        inviteFromIp: { type: "string", default: "204.13.186.218" },
        inviteFromLocation: {
          type: "string",
          default: "São Paulo, Brazil",
        },
      },
    },
  });
  // JSON Schema for validation and type-safety. Zod, and others coming soon.
}, { payloadSchema: { properties: { text: { type: 'string' } } } });
```

Once you do this, you’ll see this workflow, the steps in the workflow, step inputs, payload variables and, the rendered view of this workflow on the Echo Dev Studio:

<Frame>
  <img />
</Frame>

Here, from the Dev Studio, you or your peers can change things like the text of a button, toggle visibility of a button, static text content, etc, and have it synced with the cloud with the `Sync to Cloud` button.

### Payload vs Step Inputs

Notice that in the Echo dev studio above, we’ve used payload as well as step inputs. Here’s how you can decide if you need either or both:

* Payload is used for dynamic content that changes from one notification to another based on events occurring in your system.
* Step Inputs are for static elements or predefined options that non-technical team members can modify without altering the codebase.
* Payload is controlled by developers and passed dynamically through the novu.trigger method.
* Step Inputs are defined by developers but are meant to be utilized and modified by non-technical peers.
* Payload examples include User ID, Post ID, Comment, Order ID, 2FA token, etc., which are likely to change with each notification.
* Step Inputs examples include the text of a button, whether a section should be shown, static text content, etc., which are generally static but configurable elements.
* Payload modifications are made in the code by developers at the time of triggering a notification.
* Step Inputs can be modified directly in the UI, offering a no-code solution for non-technical team members to make changes.
* Payload data is passed during the novu.trigger method and is part of the dynamic data handling process within notification workflows.
* Step Inputs are predefined in the workflow configuration and can be adjusted through the Echo Dev Studio, affecting how notifications are rendered without changing the workflow logic.

## Syncing with the cloud, with the click of a button

Once done with the workflow, now we need to sync it to the cloud. Fortunately, Novu Framework makes it a breeze to sync changes from the local machine to the cloud and it all happens with a click of a button.

To enable our cloud environment to talk to your local Echo instance, you need to supply an Echo endpoint URL. This sets up a communication channel between our cloud environment and your local instance. To allow Novu to communicate with your local machine a tunnel will need to be generated.

The `create-novu-app` command sets up `localtunnel` for you. Running the `npm run dev` script in the project launches both the Bridge application and the tunnel solution. The tunnel URL shows up in the console output.

You can also use a tool like `ngrok`:

```bash theme={null}
// using ngrok 
ngrok http http://localhost:<YOUR_EDGE_PORT>      
```

In our case, the app is running on port 4000 so we’ll use:

```bash theme={null}
ngrok http http://localhost:4000
```

This will create a tunnel and you’ll see something like this in the terminal:

<Frame>
  <img />
</Frame>

Remember, the exact URL (`/api/novu` or similar) you expose in your application for handling Novu Framework requests is what you'd consider the `Bridge URL`.

This URL would be the endpoint within your application's domain where Novu's Worker Engine sends requests to fetch notification content or subscriber details dynamically. In our case, it is this: `https://0536-2409-40f2-1039-43e1-3053-d98e-c276-ee5.ngrok-free.app/api/echo`

So, we’ll enter this Bridge URL:

<Frame>
  <img />
</Frame>

And create diff:

<Frame>
  <img />
</Frame>

## Testing our workflow

Once you’ve synced your changes in the previous step, you’ll see a notification that says ‘Sync complete’ and you can now go to Novu Cloud using the ‘Test your workflows’ link and trigger a notification.

<Frame>
  <img />
</Frame>

You’ll see the workflow you’ve created has a blue lightning bolt icon. That icon signifies that the corresponding workflow has been created with Novu Framework:

<Frame>
  <img />
</Frame>

Simply open the workflow and you can send a test email from there.

<Note>
  Make sure that all the expected payload variables and step inputs are being sent in their respective fields!
</Note>

<Frame>
  <img />
</Frame>

This is the workflow test email in my inbox:

<Frame>
  <img />
</Frame>

Once tested, you can simply have this workflow triggered whenever you want. For instance, a typical use case is to have a workflow triggered when an event occurs. To replicate it, I’ve attached a handler function that triggers this workflow when the `submit` event fires:

Here’s a simple replication of the stipulated scenario:

```jsx theme={null}
"use client"
import Image from "next/image";
import styles from "./page.module.css";
import React, { useState } from "react";
import axios from "axios";

export default function Home() {

  const [email, setEmail] = useState('')
  const [username, setUsername] = useState('')

  const onClickHandler = async (e: React.FormEvent<HTMLFormElement>) => {
    try {
      e.preventDefault();
      await fetch("/api/users", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          email: email,
          username: username,
        }),
      });

      // console.log('working fine');
    } catch (error) {
      console.error('Error:', error);
    }
  };
  return (
    <main style={{ height: '100vh', display: 'flex', justifyContent: 'center', alignItems: 'center' }}>
      <form onSubmit={(e) => onClickHandler(e)}>
        <input
          placeholder="Enter email id"
          onChange={(e) => setEmail(e.target.value)}
          style={{
            // Add your CSS-in-JS styles here
            padding: '0.5rem',
            marginBottom: '1rem',
            borderRadius: '0.25rem',
            border: '1px solid #ccc',
            width: '100%',
            boxSizing: 'border-box',
          }}
        />
        <input
          placeholder="Enter the name of invitee"
          onChange={(e) => setUsername(e.target.value)}
          style={{
            // Add your CSS-in-JS styles here
            padding: '0.5rem',
            marginBottom: '1rem',
            borderRadius: '0.25rem',
            border: '1px solid #ccc',
            width: '100%',
            boxSizing: 'border-box',
          }}
        />
        <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'center' }}>

          <button
            style={{
              // Add your CSS-in-JS styles here
              padding: '0.5rem 1rem',
              backgroundColor: '#4CAF50',
              color: 'white',
              border: 'none',
              borderRadius: '0.25rem',
              cursor: 'pointer',
            }}
          >
            Submit
          </button>
        </div>
      </form>
    </main>
  );
}
```

And the corresponding route it hits:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<Your Novu API Key>');

export async function POST(request: Request) {
  const res = await request.json();

  await novu.trigger('<Workflow name>', {
    to: {
      subscriberId: '<subscriber ID>',
    },
    payload: {
      email: res.email,
      username: res.username,
    },
  });

  console.log('triggered')
  return Response.json({ success: true });
}
```

## More workflow examples

Creating workflows with Novu Framework is a breeze. Here are a couple of other examples from React email docs created with Novu Framework:

1. AWS Email verification example

<Frame>
  <img />
</Frame>

2. Apple invoice email example

<Frame>
  <img />
</Frame>

## Conclusion

So there you go!

This is how you create workflows using Novu Framework and deploy your changes seamlessly to the Novu cloud. You can check out the code for a [sample demo app](https://github.com/novuhq/novu-framework-nextjs-react-email-example).
Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows.

<br />

Don’t forget to share your workflows with us and as always, hit us up on Discord with any questions you might have!


# How to send notifications with Remix and React email
Source: https://v0.x-docs.novu.co/guides/framework-guides/framework-remix

Learn how to send email notifications with Remix, React email and Novu

# Introduction

Learn how to send notifications with Remix, React email and Novu. You can check out the complete code for a [working app](https://github.com/novuhq/novu-framework-remix-example).

## Prerequisites

* A Novu account
* Node installed on your machine
* A working Remix app

## Follow these Steps

### 1. Install all dependencies including react email components

```jsx theme={null}
  npm install @novu/framework @react-email/components react-email
```

### 2. Integrate Novu with Remix

Within the `app/routes` directory, create an `api.novu.tsx` file.

```jsx theme={null}
// app/routes/api.novu.tsx

import { serve } from "@novu/framework/remix";
import { client, signUpWorkflow } from "~/novu/workflows";

const handler = serve({
    client: client,
    workflows: [signUpWorkflow]
  });
  
export { handler as action, handler as loader };
```

### 3. Create an email template in your Remix app

Within the `app` directory, create an `emails` folder and add an email template file to it.

In this scenario, create a `vercel-invite-user.tsx` file and the code below to it:

```ts theme={null}
// app/emails/vercel-invite-user.tsx

import {
    Body,
    Button,
    Container,
    Column,
    Head,
    Heading,
    Hr,
    Html,
    Img,
    Link,
    render,
    Row,
    Section,
    Text,
    Tailwind,
  } from "@react-email/components";
  
  interface VercelInviteUserEmailProps {
    username?: string;
    userImage?: string;
    invitedByUsername?: string;
    invitedByEmail?: string;
    teamName?: string;
    teamImage?: string;
    inviteLink?: string;
    inviteFromIp?: string;
    showJoinButton?: boolean;
    inviteFromLocation?: string;
    buttonText?: string
  }
  
  const baseUrl = process.env.VERCEL_URL
    ? `https://${process.env.VERCEL_URL}`
    : "";
  
  export const VercelInviteUserEmail = ({
    username,
    userImage,
    invitedByUsername,
    invitedByEmail,
    teamName,
    teamImage,
    inviteLink,
    inviteFromIp,
    inviteFromLocation,
    showJoinButton,
    buttonText
  }: VercelInviteUserEmailProps) => {
  
    return (
      <Html>
        <Head />
        <Tailwind>
          <Body className="bg-white my-auto mx-auto font-sans px-2">
            <Container className="border border-solid border-[#eaeaea] rounded my-[40px] mx-auto p-[20px] max-w-[465px]">
              <Section className="mt-[32px]">
                <Img
                  src={`https://react-email-demo-ndjnn09xj-resend.vercel.app/static/vercel-logo.png`}
                  width="40"
                  height="37"
                  alt="Vercel"
                  className="my-0 mx-auto"
                />
              </Section>
              <Heading className="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
                Join <strong>{teamName}</strong> on <strong>Vercel</strong>
              </Heading>
              <Text className="text-black text-[14px] leading-[24px]">
                Hello {username},
              </Text>
              <Text className="text-black text-[14px] leading-[24px]">
                <strong>{invitedByUsername}</strong> (
                <Link
                  href={`mailto:${invitedByEmail}`}
                  className="text-blue-600 no-underline"
                >
                  {invitedByEmail}
                </Link>
                ) has invited you to the <strong>{teamName}</strong> team on{" "}
                <strong>Vercel</strong>.
              </Text>
              <Section>
                <Row>
                  <Column align="right">
                    <Img
                      className="rounded-full"
                      src={userImage}
                      width="64"
                      height="64"
                    />
                  </Column>
                  <Column align="center">
                    <Img
                      src={`https://react-email-demo-ndjnn09xj-resend.vercel.app/static/vercel-arrow.png`}
                      width="12"
                      height="9"
                      alt="invited you to"
                    />
                  </Column>
                  <Column align="left">
                    <Img
                      className="rounded-full"
                      src={teamImage}
                      width="64"
                      height="64"
                    />
                  </Column>
                </Row>
              </Section>
              {showJoinButton && (
                <Section className="text-center mt-[32px] mb-[32px]">
                  <Button
                    className="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center px-5 py-3"
                    href={inviteLink}
                  >
                    {buttonText}
                  </Button>
                </Section>
              )}
              <Text className="text-black text-[14px] leading-[24px]">
                or copy and paste this URL into your browser:{" "}
                <Link href={inviteLink} className="text-blue-600 no-underline">
                  {inviteLink}
                </Link>
              </Text>
              <Hr className="border border-solid border-[#eaeaea] my-[26px] mx-0 w-full" />
              <Text className="text-[#666666] text-[12px] leading-[24px]">
                This invitation was intended for{" "}
                <span className="text-black">{username}</span>. This invite was
                sent from <span className="text-black">{inviteFromIp}</span>{" "}
                located in{" "}
                <span className="text-black">{inviteFromLocation}</span>. If you
                were not expecting this invitation, you can ignore this email. If
                you are concerned about your account's safety, please reply to
                this email to get in touch with us.
              </Text>
            </Container>
          </Body>
        </Tailwind>
      </Html>
    );
  };
  
  VercelInviteUserEmail.PreviewProps = {
    username: "alanturing",
    userImage: `${baseUrl}/static/vercel-user.png`,
    invitedByUsername: "Alan",
    invitedByEmail: "alan.turing@example.com",
    teamName: "Enigma",
    teamImage: `${baseUrl}/static/vercel-team.png`,
    inviteLink: "https://vercel.com/teams/invite/foo",
    inviteFromIp: "204.13.186.218",
    inviteFromLocation: "São Paulo, Brazil",
  } as VercelInviteUserEmailProps;
  
  export default VercelInviteUserEmail;
  
  export function renderEmail(input: any, payload: any) {
    return render(<VercelInviteUserEmail {...input}{...payload} />);
  }
```

### 4. Create a Novu Workflow

Next, create a Novu workflow with an email step. This code-first notification workflow approach makes it easy for product teams to modify notification content.

Within the `app` directory, create an `novu` folder and add a `workflows.ts` file to it. Copy/paste the code below to the recently created file.

```jsx theme={null}
// app/novu/workflows.ts

import { Client, workflow } from '@novu/framework';
import { renderEmail } from '~/emails/vercel-invite-user';

export const client = new Client({

  apiKey: process.env.NOVU_API_KEY,
  /**
   * Disable this flag only during local development
   * For production this should be true
   */
  strictAuthentication: process.env.NODE_ENV !== "development"
});

export const signUpWorkflow = workflow('new-signup', async ({ step, payload }) => {
  // Send a welcome email
  await step.email('send-email', async (inputs) => {
    return {
      subject: `Welcome to sending emails with Novu & Remix`,
      body: renderEmail(inputs, payload),
    };
  }, {
    inputSchema: {
      type: "object",
      properties: {
        showJoinButton: { type: "boolean", default: true },
        buttonText: { type: "string", default: "Join the team" },
        userImage: {
          type: "string",
          default: "https://react-email-demo-bdj5iju9r-resend.vercel.app/static/vercel-user.png",
          format: "uri",
        },
        invitedByUsername: { type: "string", default: "Alan" },
        invitedByEmail: {
          type: "string",
          default: "alan.turing@example.com",
          format: "email",
        },
        teamName: { type: "string", default: "Team Awesome" },
        teamImage: {
          type: "string",
          default: "https://react-email-demo-bdj5iju9r-resend.vercel.app/static/vercel-team.png",
          format: "uri",
        },
        inviteLink: {
          type: "string",
          default: "https://vercel.com/teams/invite/foo",
          format: "uri",
        },
        inviteFromIp: { type: "string", default: "204.13.186.218" },
        inviteFromLocation: {
          type: "string",
          default: "São Paulo, Brazil",
        },
      },
    },
  });
  // JSON Schema for validation and type-safety. Zod, and others coming soon.
}, { payloadSchema: { properties: { text: { type: 'string' } } } });
```

### 5. Preview Email Workflow & Sync to Novu Cloud

Open Novu Dev Studio to preview and make changes to the email workflow as needed via the command below:

```jsx theme={null}
npx novu-labs@latest echo
```

1. Run the Studio

<Frame>
  <img />
</Frame>

**Note:** Use the port on which your Remix app is running for the Bridge endpoint so that the Novu Dev Studio can connect to your API route as highlighted in the image above.

2. Check out the signup email workflow and test

<Frame>
  <img />
</Frame>

3. Deploy to Novu Cloud when you're done.

On the top right(as seen in the image above) of the Novu Dev Studio, you can sync to Novu Cloud when you're done working locally.

**Note:** You'll need to create a local tunnel that the Novu Cloud environment can reach for local experimentation purposes. Ngrok is a good tunnel.

### 6. Send a Notification

Trigger a notification using the recently deployed workflow either via your [Novu Cloud dashboard](https://web.novu.co) or [code](/quickstarts/react#trigger-a-notification).

```js theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<API_KEY>");

novu.trigger("new-signup", {
  to: {
    subscriberId: "789",
  }
});
```

Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows.


# How to send notifications with Svelte and Svelte email
Source: https://v0.x-docs.novu.co/guides/framework-guides/framework-svelte

Learn how to send email notifications with Svelte, Svelte email and Novu

# Introduction

Learn how to send notifications with Svelte, Svelte email and Novu. You can check out the complete code for a [working app](https://github.com/novuhq/novu-svelte-email).

## Prerequisites

* A Novu account
* Node installed on your machine
* A working SvelteKit app

## Follow these Steps

### 1. Install all dependencies

```jsx theme={null}
  npm install @novu/framework svelte-email
```

### 2. Integrate Novu with SvelteKit

Within the `src/routes` directory, create an `api/novu` folder and add a `+server.ts` file to it.

```jsx theme={null}
// src/routes/api/novu/+server.ts

import { svelteWorkflow, client } from '$lib/novu/workflows';
import { serve } from '@novu/framework/sveltekit';

export const { GET, POST, PUT } = serve({ client: client, workflows: [svelteWorkflow] });
```

### 3. Create an email template in Svelte

Within the `src/lib` directory, create an `emails` folder and add an email template in a `.svelte` file to it.

For example, `airbnb-review.svelte`:

```ts theme={null}
// src/lib/emails/airbnb-review.svelte

<script lang="ts">
	import {
		Button,
		Container,
		Head,
		Heading,
		Hr,
		Html,
		Img,
		Link,
		Preview,
		Section,
		Text
	} from 'svelte-email';

        const baseUrl = 'https://svelte-email-rjaapma15-konzeptfabrik.vercel.app';

	export let authorName = 'Alex';
	export let showFeedbackButton = true;
	export let showLogoImage = true;
	export let feedbackButtonText = 'Send My Feedback';
	export let authorImage = `${baseUrl}/airbnb-review-user.jpeg`;
	export let logoImage = `${baseUrl}/airbnb-logo.png`;
	export let reviewText = `“Zeno was a great guest! Easy communication, the apartment was left
	  in great condition, very polite, and respectful of all house rules.
	  He’s welcome back anytime and would easily recommend him to any
	  host!”`;
	export let bottomAddress = "Airbnb, Inc., 888 Brannan St, San Francisco, CA 94103";

	const previewText = `Read ${authorName}'s review`;

	const fontFamily =
		'-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen-Sans,Ubuntu,Cantarell,"Helvetica Neue",sans-serif';

	const main = {
		backgroundColor: '#ffffff'
	};

	const container = {
		margin: '0 auto',
		padding: '20px 0 48px',
		width: '580px'
	};

	const userImage = {
		margin: '0 auto',
		marginBottom: '16px',
		borderRadius: '50%'
	};

	const heading = {
		fontFamily,
		fontSize: '32px',
		lineHeight: '1.3',
		fontWeight: '700',
		color: '#484848'
	};

	const paragraph = {
		fontFamily,
		fontSize: '18px',
		lineHeight: '1.4',
		color: '#484848'
	};

	const review = {
		...paragraph,
		padding: '24px',
		backgroundColor: '#f2f3f3',
		borderRadius: '4px'
	};

	const button = {
		fontFamily,
		backgroundColor: '#ff5a5f',
		borderRadius: '3px',
		color: '#fff',
		fontSize: '18px',
		textDecoration: 'none',
		textAlign: 'center' as const,
		display: 'block',
		width: '100%'
	};

	const link = {
		...paragraph,
		color: '#ff5a5f',
		display: 'block'
	};

	const reportLink = {
		fontFamily,
		fontSize: '14px',
		color: '#9ca299',
		textDecoration: 'underline'
	};

	const hr = {
		borderColor: '#cccccc',
		margin: '20px 0'
	};

	const footer = {
		fontFamily,
		color: '#9ca299',
		fontSize: '14px',
		marginBottom: '10px'
	};

</script>

<Html>
	<Head />
	<Preview preview={previewText} />
	<Section style={main}>
		<Container style={container}>
            {#if showLogoImage}
			    <Img src={logoImage} width="96" height="30" alt="Airbnb" />
            {/if}
			<Section>
				<Img src={authorImage} width="96" height="96" alt={authorName} style={userImage} />
			</Section>
			<Heading style={heading}>Here's what {authorName} wrote</Heading>
			<Text style={review}>{reviewText}</Text>
			<Text style={paragraph}>
				Now that the review period is over, we’ve posted {authorName}’s review to your Airbnb
				profile.
			</Text>
			<Text style={paragraph}>
				While it’s too late to write a review of your own, you can send your feedback to {authorName}
				using your Airbnb message thread.
			</Text>
			<Section style={{ padding: '16px 0 20px' }}>
                {#if showFeedbackButton}
				    <Button pY={19} style={button} href="https://airbnb.com/" >{feedbackButtonText}</Button>
                {/if}
			</Section>
			<Hr style={hr} />
			<Text style={{ ...paragraph, fontWeight: '700' }}>Common questions</Text>
			<Text>
				<Link href="https://airbnb.com/help/article/13" style={link}>How do reviews work?</Link>
			</Text>
			<Text>
				<Link href="https://airbnb.com/help/article/1257" style={link}>
					How do star ratings work?
				</Link>
			</Text>
			<Text>
				<Link href="https://airbnb.com/help/article/995" style={link}>
					Can I leave a review after 14 days?
				</Link>
			</Text>
			<Hr style={hr} />
			<Text style={footer}>{bottomAddress}</Text>
			<Link href="https://airbnb.com" style={reportLink}>Report unsafe behavior</Link>
		</Container>
	</Section>
</Html>
```

### 4. Create a Novu Workflow

Next, create a Novu workflow with an email step. This code-first notification workflow approach makes it easy for product teams to modify notification content.

```jsx theme={null}
// src/lib/novu/workflows.ts

import { Client, workflow } from '@novu/framework';
import { render } from 'svelte-email';
import AirbnbReview from '$lib/emails/airbnb-review.svelte';

export const client = new Client({
  
  /**
   * The Novu API key is needed for when you
   * need to sync to Novu Cloud
   */
  apiKey: process.env.NOVU_API_KEY,
  /**
   * Disable this flag only during local development
   * For production this should be true
   */
  strictAuthentication: process.env.NODE_ENV !== "development"
});

export const svelteWorkflow = workflow('airbnb-review', async ({ step, payload }) => {
    await step.email(
        'send-email',
        async (inputs) => {
            const html = render({
                template: AirbnbReview,
                props: {
                    authorName: inputs.authorName,
                    showFeedbackButton: inputs.showFeedbackButton,
                    showLogoImage: inputs.showLogoImage,
                    feedbackButtonText: inputs.feedbackButtonText,
                    bottomAddress: inputs.bottomAddress,
                    authorImage: inputs.authorImage,
                    logoImage: inputs.logoImage
                },
            });
            return {
                subject: `Here's Your Host Feedback`,
                body: html,
            }
        }, {
            inputSchema: {
                type: "object",
                properties: {
                  showFeedbackButton: { type: "boolean", default: true },
                  showLogoImage: { type: "boolean", default: true },
                  authorName: { type: "string", default: "Alex" },
                  feedbackButtonText: { type: "string", default: "Send My Feedback" },
                  authorImage: {
                    type: "string",
                    default: "https://react-email-demo-bdj5iju9r-resend.vercel.app/static/vercel-user.png",
                    format: "uri",
                  },
                  logoImage: {
                    type: "string",
                    default: "https://svelte-email-rjaapma15-konzeptfabrik.vercel.app/airbnb-logo.png",
                    format: "uri",
                  },
                  bottomAddress: {
                    type: "string",
                    default: "Airbnb, Inc., 888 Brannan St, San Francisco, CA 94103",
                  },
                },
            },
        });
    }
);
```

### 5. Preview Email Workflow & Sync to Novu Cloud

Open Dev Studio to preview and make changes to the email workflow as needed via the command below:

```jsx theme={null}
npx novu-labs@latest echo
```

1. Run the Studio

<Frame>
  <img />
</Frame>

**Note:** Use the port on which your Svelte app is running for the Bridge endpoint so that the Novu Dev Studio can connect to your API route.

2. Check out the email workflow and test

<Frame>
  <img />
</Frame>

3. Deploy to Novu Cloud when you're done.

On the top right of the Novu Dev Studio, you can sync to Novu Cloud when you're done working locally.

**Note:** You'll need to create a local tunnel that the Novu Cloud environment can reach for local experimentation purposes. Ngrok is a good tunnel.

### 6. Send a Notification

Trigger a notification using the recently deployed workflow either via your [Novu Cloud dashboard](https://web.novu.co) or [code](/quickstarts/react#trigger-a-notification).

Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows.


# How to send OTP verification email notifications with React-email
Source: https://v0.x-docs.novu.co/guides/framework-guides/otp

Learn how to send OTP verification email notifications with React-email in your NextJS app

## Introduction

In this guide, you’ll learn how to send OTP verification email notifications using the React-email package. Follow these steps:

## Getting started

Integrating Novu’s code-first workflow with React.Email for your Next.js application can be done in a few steps:

1. Create a NextJS app and wait for the installation:

```bash theme={null}
npx create-novu-app@latest --api-key=<YOUR_API_KEY>

// The command will ask you if you want to include react-email into your new project.
```

2. Once this installation is complete, simply `cd` into the directory and start your app using the `npm run dev` command.

## Using a code-first workflow

1. Write an email template - To write an email template, you can look over some of the examples in the [React Email](https://react.email/examples) documentation to get inspiration. In our case, this is the template:

```ts theme={null}
import {
    Body,
    Button,
    Container,
    Head,
    Heading,
    Hr,
    Html,
    Img,
    Link,
    Preview,
    Section,
    Text,
    render
} from "@react-email/components";
import * as React from "react";

interface LinearLoginCodeEmailProps {
    validationCode?: string;
    showJoinButton?: boolean;
    buttonText?: string;
    inviteLink?: string;
    logoURL?: string;
    inviteFromLocation?: string;
    inviteFromIp?: string;
    supportEmail?: string;
}

export const LinearLoginCodeEmail = ({
    validationCode,
    showJoinButton,
    buttonText,
    inviteLink,
    logoURL,
    inviteFromIp,
    inviteFromLocation,
    supportEmail
}: LinearLoginCodeEmailProps) => (
    <Html>
        <Head />
        <Preview>Your login code for Linear</Preview>
        <Body style={main}>
            <Container style={container}>
                <Img
                    src={`${logoURL}`}
                    width="42"
                    height="42"
                    alt="Linear"
                    style={logo}
                />
                <Heading style={secondary}>
                    Your login code for Linear
                </Heading>
                <Section style={buttonContainer}>
                    {showJoinButton && (
                        <Section className="text-center mt-[32px] mb-[32px]">
                            <Button
                                style={button}
                                href={inviteLink}
                            >
                                {buttonText}
                            </Button>
                        </Section>
                    )}
                </Section>
                <Text style={paragraph}>
                    This link and code will only be valid for the next 5 minutes. If the
                    link does not work, you can use the login verification code directly:
                </Text>
                <Section style={codeContainer}>
                    <Text style={code}>{validationCode}110658</Text>
                </Section>
                <Hr style={hr} />
                <Text style={paragraphSupport}>Not expecting this email?</Text>
                <Text style={paragraphSupport}>
                    This invite was
                    sent from <span style={paragraphSupportText}>{inviteFromIp}</span>{" "}
                    located in{" "}
                    <span style={paragraphSupportText}>{inviteFromLocation}</span>.
                </Text>
                <Text style={paragraphSupport}>
                    Please contact{" "}
                    <Link href="mailto:suport@linear.com" style={link}>
                        {supportEmail}
                    </Link>{" "}
                    if you did not request this code.
                </Text>
            </Container>
        </Body>
    </Html>
);

LinearLoginCodeEmail.PreviewProps = {
    validationCode: "tt226-5398x",
} as LinearLoginCodeEmailProps;

export default LinearLoginCodeEmail;

const logo = {
    borderRadius: 21,
    width: 42,
    height: 42,
};

const main = {
    backgroundColor: "#ffffff",
    fontFamily:
        '-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen-Sans,Ubuntu,Cantarell,"Helvetica Neue",sans-serif',
};

const container = {
    margin: "0 auto",
    padding: "20px 0 48px",
    maxWidth: "560px",
};

const secondary = {
    color: "#000",
    display: "inline-block",
    fontFamily: "HelveticaNeue-Medium,Helvetica,Arial,sans-serif",
    fontSize: "20px",
    fontWeight: 500,
    lineHeight: "24px",
    marginBottom: "0",
    marginTop: "2rem",
    textAlign: "center" as const,
};

const paragraphSupportText = {
    fontSize: "15px",
    fontWeight: "700",
};

const paragraph = {
    margin: "0 0 15px",
    fontSize: "15px",
    lineHeight: "1.4",
    color: "#3c4149",
};

const buttonContainer = {
    padding: "27px 0 27px",
};

const button = {
    backgroundColor: "#5e6ad2",
    borderRadius: "3px",
    fontWeight: "600",
    color: "#fff",
    fontSize: "15px",
    textDecoration: "none",
    textAlign: "center" as const,
    display: "block",
    padding: "11px 23px",
};

const hr = {
    borderColor: "#dfe1e4",
    margin: "42px 0 26px",
};

const code = {
    color: "#000",
    display: "inline-block",
    fontFamily: "HelveticaNeue-Bold",
    fontSize: "16px",
    fontWeight: 700,
    letterSpacing: "6px",
    lineHeight: "40px",
    paddingBottom: "8px",
    paddingTop: "8px",
    margin: "0 auto",
    width: "100%",
    textAlign: "center" as const,
};

const paragraphSupport = {
    color: "#444",
    fontSize: "15px",
    fontFamily: "HelveticaNeue,Helvetica,Arial,sans-serif",
    letterSpacing: "0",
    lineHeight: "23px",
    padding: "0 40px",
    margin: "0",
    textAlign: "center" as const,
};

const link = {
    color: "#444",
    textDecoration: "underline",
};

const codeContainer = {
    background: "rgba(0,0,0,.05)",
    borderRadius: "4px",
    margin: "16px auto 14px",
    verticalAlign: "middle",
    width: "280px",
};

export function renderOTPEmail(payload: any) {
    return render(<LinearLoginCodeEmail {...payload} />);
}
```

2. Launch Dev Studio - Novu’s code-first approach lets you see how the template would look when rendered, right when defining it, using the Dev Studio. To launch the dev studio locally you can run `npx novu-labs@latest echo`. The Dev Studio will be started by default on port 2022, and accessible via: [http://localhost:2022](http://localhost:2022)

<Frame>
  <img />
</Frame>

3. Define a workflow that uses that template to send notifications - In this step, we need to define a workflow that uses the template we wrote above to render the email notification:

```ts theme={null}
import { Client, workflow } from "@novu/framework";
import { renderOTPEmail } from "./otp";

export const client = new Client({
  apiKey: process.env.NOVU_API_KEY,
  /**
   * Disable this flag only during local development
   */
  strictAuthentication: process.env.NODE_ENV !== "development",
});

export const otpFlow = workflow('otp-flow', async ({ step, payload }) => {
  // Send a welcome email
  await step.email('send-email', async (inputs) => {
    return {
      subject: `Here's your verification code, Sumit!`,
      body: renderOTPEmail(inputs, payload),
    };
  }, {
    inputSchema: {
      type: "object",
      properties: {
        showJoinButton: { type: "boolean", default: true },
        buttonText: { type: "string", default: "Login to Linear" },
        logoURL: {
          type: "string",
          default: "https://react-email-demo-7qy8spwep-resend.vercel.app/static/linear-logo.png",
          format: "uri",
        },
        supportEmail: { type: "string", default: "support@linear.co" },
        validationCode: { type: "string", default: "tt226-5398x" },
        inviteLink: {
          type: "string",
          default: "https://linear.app",
          format: "uri",
        },
        inviteFromIp: { type: "string", default: "204.13.186.218" },
        inviteFromLocation: {
          type: "string",
          default: "São Paulo, Brazil",
        },
      },
    },
  });
  // JSON Schema for validation and type-safety. Zod, and others coming soon.
}, { payloadSchema: { properties: { text: { type: 'string' } } } });
```

4. Triggering the workflow - Lastly, we need to trigger the workflow we created above. Here’s how to trigger it:

```ts theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

export async function POST(request: Request) {
  const res = await request.json();

  await novu.trigger('otp-flow', {
    to: {
      subscriberId: 'new-user',
    },
    payload: {
      email: res.email,
      username: res.username,
    },
  });

  console.log('triggered')
  return Response.json({ success: true });
}
```

When we trigger this workflow, here’s the email received on the client-side:

<Frame>
  <img />
</Frame>

That’s it!

That’s how you create and use an OTP workflow. You can check out [our docs](https://docs.novu.co/guides/framework-guides/framework-react-email) for a hands on guide with more in-depth instructions.

Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows.

Don’t forget to share your workflows with us and as always, hit us up on Discord with any questions you might have!


# Empowering Product Teams to Manage Notification Workflows
Source: https://v0.x-docs.novu.co/guides/framework-guides/product

Enabling product teams to independently manage and optimize notification workflows for improved efficiency and user experience

# Introduction

Novu’s code-first workflow empowers product teams to manage notification for end-users independently once the engineering teams have built and delivered the notification platform for the product.

Let’s see how product teams can leverage it:

1. **Engineering Team sets things up:** Engineering teams integrate Novu’s code-first workflows into their application. This involves setting up the structure of notification workflows in the codebase, defining events, steps, inputs, payload, etc. These workflows are functions that execute business logic and need to be set only once.
2. **Empowering Non-Technical Teams:** Once the foundational workflows are established, product teams can take over! Code-first workflows allow non-technical users to modify workflows safely without breaking critical integrations. Through an exposed Inputs interface, product teams can adjust notification content and behaviour, tailoring the user experience without needing to dive into the code at all. This helps both teams win - product teams are empowered to manage and optimize notifications independently, creating a dynamic and user-centric notification system without constant reliance on engineering teams.
3. **Insights and Optimization**: Further, with Novu’s Web Dashboard, Product teams gain valuable insights into last-mile delivery from the activity monitor. This enables them to refine notification strategies and optimize for better user satisfaction.

This collaborative approach between the Engineering and Product teams allows both teams to focus on their strengths, resulting in a more efficient and effective notification strategy, without constant interruptions in each other’s flow.

## Customising the workflow

To demonstrate the customizability, we’ll assume that the Engineering team has successfully delivered the basic setup as outlined in [one of our guides.](https://docs.novu.co/guides/framework-guides/framework-react-email)

1. To start things off, you only need to visit the workflow section in our [Web Dashboard](https://web.novu.co/).

<Frame>
  <img />
</Frame>

* You’ll see the blue lightning bolt icon right next to the workflow name symbolising that it is a code-first workflow.
* Now, simply click on the workflow to open it and make your desired changes.
* The green `Sync` indicator on the top right corner means that your app is successfully connected with Novu.

2. Once you open a workflow, you’ll see all the steps of the workflow:

<Frame>
  <img />
</Frame>

3. Simply, select a node to see the rendered view. This is what will get sent to the end user.

<Frame>
  <img />
</Frame>

4. To start making changes, simply click on either of the two buttons highlighted below:

<Frame>
  <img />
</Frame>

5. Once you click on it, you’ll be taken to the edit view where you’ll see real-time preview of the workflow. You can make changes to the step inputs on the right-hand side and the rendered view will update in real-time to reflect those changes

<Frame>
  <img />
</Frame>

6. Let's take a look at what payload and step inputs are:
7. In almost all the scenarios, you’ll be tweaking and modifying step inputs and the workflow editor makes it blazing fast and effortlessly simple. Simply change the text of the respective field or button or toggle any button on or off till the rendered view becomes what you want your end users to receive. Here’s how you can tweak it:

<Frame>
  <img />
</Frame>

## Conclusion

The collaboration resulting from Novu’s code-first workflow increases agility, enabling rapid iterations and quick adjustments based on user feedback. It fosters effective collaboration between product and engineering teams, resulting in a more efficient workflow and improved user notifications.


# How to use Headless Notification Center
Source: https://v0.x-docs.novu.co/guides/headless-notification-center-guide

Use the headless version of the notification center

## Introduction

In this guide, you'll learn about how to use the headless version of our notification center. The headless version is useful for scenarios in which a lightweight solution for integrating notification functionality into a web app that is completely unstyled (so that you can style it as per your wish) is required.

<br />

You can find the entire code ( front-end as well as back-end ) of this app [here.](https://github.com/novuhq/novu-headless-demo-app)

## What is the headless notification center

The headless version of Novu's notification library package provides users with a lightweight solution for integrating notification functionality into their web applications.

<br />

With just the essential API methods, users can easily incorporate our notification system into any framework or vanilla JavaScript project, without being constrained by our default UI or dependencies.

This gives the users of the headless notification center greater flexibility and control over what the end-users of a product see and experience.

## How to use the headless notification center

To get started with this you need:

1. A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-guides-headless) if you don’t have one yet.
2. A working dev environment in the framework of your choice (or vanilla JS). Here, we'll use a React environment

## Workflow set up in Novu

Once, you have signed up for Novu and have a dev environment, follow the steps below:

1. Head over to the Novu Dashboard.
2. Click `Workflows` on the left sidebar of your Novu dashboard.
3. Click the `Create Workflow` button on the top right:

<Frame>
  <img />
</Frame>

Once you click the `create workflow` button, you’ll see a dropdown. Select `blank workflow` from the dropdown:

<Frame>
  <img />
</Frame>

You’ll now be taken to the workflow editor:

<Frame>
  <img />
</Frame>

Once here, you can add the channels you want to use for sending notifications and configure them. For this guide, we’ll use the `In-App` channel.

<Frame>
  <img />
</Frame>

The `In-app` node allows you to further customize the notifications that will get sent, as per your need. In our case, it is a simple `description`, which will contain the text that will be entered from the front end. Here's the `in-app` node for your reference:

<Frame>
  <img />
</Frame>

Here's a brief overview of all the options:

* **1-Preview**: This shows you a glimpse of what each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.

Once you’re done configuring this to your liking, click on the `update` button on the top right. It'll automatically create a trigger code that you can use in your app. To get it, click on the `get snippet` button on the top right and copy it:

<Frame>
  <img />
</Frame>

<br />

Let's now see how to add it to our app!

## Pre-requisites:

To be able to use the headless notification center, you'll first need the following:

1. `applicationIdentifier`: You can find this from the `settings` menu in the [Novu web dashboard.](https://web.novu.co/settings?utm_campaign=docs-guides-headless)
2. `subscriberID`: In most real-world apps, you'll get this from a database. It is used to uniquely identify the entity to whom a notification will be delivered. In our case, we're assuming the `subscriberID` to be `12345`.

## Setting up the back end:

For our demo app, we're setting up the back end as follows:

1. Install the Novu package. Open your terminal and run the following command:

```bash theme={null}
npm install @novu/node
```

Once installed, you can import Novu into your app and initialize it using your Novu account credentials. This step establishes a connection between your app and the Novu notification service.

```bash theme={null}
import { Novu } from '@novu/node';
const novu = new Novu('<NOVU_API_KEY>');
```

<Note>
  Replace the `<NOVU_API_KEY>` value with the authentic key from the API Key section of your [Novu Dashboard.](http://web.novu.co/?utm_campaign=docs-guides-headless)
</Note>

<Note>
  🔑 Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

Using the above info, we'll write a function that will help us interact with Novu's notification system:

```javascript theme={null}
import { Novu } from '@novu/node';

export const notification = async (description) => {
    const novu = new Novu("<NOVU_API_KEY>");
    await novu.subscribers.identify(process.env.SUSBSCRIBER_ID, {
        firstName: 'newSubForHeadless',
    });

// code snippet copied when creating the workflow
    await novu.trigger('headless-demo', {
        to: {
            subscriberId: process.env.SUSBSCRIBER_ID
        },
        payload: {
            description: description
        }
    });

}
```

After this, we'll set up a simple controller function for handling notifications:

```javascript theme={null}
import { notification } from "../novu/novu.js";

export const notifController = async (req,res) => {
    const{description} = req.body;
    try {
        await notification(description)
        res.status(201).json({message:"Subscriber created successfully"});
    } catch (error) {
        console.log("notifController error:",error);
        res.status(500).json({message: error.message})
    }
}
```

And finally, we'll need to establish routes that we'll hit from the front end:

```javascript theme={null}
import express from "express";
import { notifController } from "../controller/notif.js";

const router = express.Router();

router.post("/create-sub",notifController);

export default router;
```

Now, we'll move to the front end because that's where all the magic happens!

## Setting up the front end:

In the front end, install the headless package:

```bash theme={null}
npm install @novu/headless
```

Then, import it and initialize the headless service:

```javascript theme={null}
import { HeadlessService, FetchResult, ISession } from '@novu/headless';

 useEffect(() => {

        const headlessService = new HeadlessService({
            applicationIdentifier: 'SWMw97ec1ZNA',
            subscriberId: '12345',
        });

        headlessService.initializeSession({
            listener: (res) => {
            },
            onSuccess: (session) => {
                headlessServiceRef.current = headlessService;
                fetchNotifications();
            },
            onError: (error) => {
                console.log("headlessSice error:", error);
            },
        })

    }, [fetchNotifications])
```

We've added the `fetchNotifications` function inside a useEffect because we want the effect to run whenever the `fetchNotifications` executes. Here's the `fetchNotifications` function for reference:

```javascript theme={null}
const fetchNotifications = useCallback(() => {
        const headlessService = headlessServiceRef.current;
        if (headlessService) {
            headlessService.fetchNotifications({
                listener: ({ data, error, isError, isFetching, isLoading, status }) => {
                    // Handle the state of the fetching process and errors here.
                },
                onSuccess: (response) => {

                    // Handle the fetched notifications here.
                    setNotifications(response.data); // Store notifications in the state
                },
                page: pageNum, // page number to be fetched
            });
        }
    }, [pageNum])
```

Here, we've memoized the `fetchNotifications` to optimize performance and passed `pageNum` in a dependency array so that it reruns when the page number changes.

<br />

You can refer to the entire context [here](https://github.com/novuhq/novu-headless-demo-app/blob/main/frontend/src/context/NotificationContext.js) for a better understanding.

We've also used several methods related to the Headless Notification Center package. You can find the complete list [here.](/notification-center/client/headless/api-reference)

The methods that we've used in our app are `markNotificationsAsRead`, `deleteNotification`, and `markAllMessagesAsRead`. They are as follows:

```javascript theme={null}

    const markNotificationsAsRead = (messageIds) => {
        if (!Array.isArray(messageIds)) {
            messageIds = [messageIds];
        }

        const headlessService = headlessServiceRef.current;

        if (headlessService) {
            headlessService.markNotificationsAsRead({
                messageId: messageIds,
                listener: (result) => {
                },
                onError: (error) => {
                    console.error('Error marking notifications as read:', error);
                },
            });
        }

    };


const deleteNotification = (messageId) => {
        const headlessService = headlessServiceRef.current;
        if (headlessService) {
            headlessService.removeNotification({
                messageId: messageId,
                listener: function (result) {
                },
                onSuccess: function (message) {
                },
                onError: function (error) {
                    console.error(error);
                },
                messageIds: 'messageOne',
            });

        }
    }

    const markAllMessagesAsRead = (feedId) => {
        const headlessService = headlessServiceRef.current;

        headlessService.markAllMessagesAsRead({
            listener: (result) => {
                console.log(result);
                // Handle the result of marking all messages as read
                // You can update the state or perform other actions here
            },
            onError: (error) => {
                console.error('Error marking all messages as read:', error);
                // Implement error handling if needed
            },
            feedId: feedId, // Pass the feed ID here, it can be an array or a single ID
        });
    };
```

<Note>
  You can view the entire API reference [here](/notification-center/client/headless/api-reference) and pick up the methods that you'd like to use for your specific requirements.
</Note>

### Coding the UI up:

On the UI front, we have a simple form with a submit handler function and a couple of components:

```javascript theme={null}
const Body = () => {

    const [description, setDescription] = useState('');
    const { active, setActive } = useNotification();
    const onSubmitHandler = async e => {
        e.preventDefault()
        await axios.post('https://headless-backend-qx89.onrender.com/api/v1/create-sub', { description })

        setDescription('')
        setActive(true)
    }
    const onChangeHandler = e => {
        setDescription(e.target.value);
    }
    return (
        <div className='body-container'>
            <p>Enter notification text</p>
            <form onSubmit={onSubmitHandler} className="input-form">
                <input className="input" value={description} onChange={onChangeHandler} placeholder="Enter notification text" />
                <button className="form-btn">Send</button>
            </form>
        </div>
    )
}
```

The first component is the `appBar` component which includes a bell icon, which can show notifications in a modal when clicked. The modal is displayed when showModal is true, and the modal can be closed by clicking outside of it. The component interacts with the notification-related functionalities provided by the useNotification hook:

```javascript theme={null}
const AppBar = () => {
    const [showModal, setShowModal] = useState(false);
    const modalRef = useRef(null);

    const { fetchNotifications, setActive, active } = useNotification();

    const handleShowNotification = async (e) => {
        e.stopPropagation();
        setShowModal((prev) => !prev);
        await fetchNotifications();
        setActive(false);
    };
    const handleCloseModal = () => {
        setShowModal(false);
    }
    useEffect(() => {
        const handleDocumentClick = e => {
            if (modalRef.current && !modalRef.current.contains(e.target)) {
                handleCloseModal();
            }
        }
        if (showModal) {
            document.addEventListener('click', handleDocumentClick);
        }
        return () => {
            document.removeEventListener('click', handleDocumentClick)
        }
    }, [showModal])

    return (
        <div>
            <div className='app-bar-container'>
                <span onClick={handleShowNotification} className='bell-icon'>
                    <BsBell />
                    <div className={`${active ? `active` : ''}`}>
                        <div className='dot'></div>
                    </div>
                </span>
            </div>
            <div className={`modal-div ${showModal ? 'modal-show' : ''}`} ref={modalRef}>
                {showModal && (<NotificationModal />)}
            </div>
        </div>
    );
};

export default AppBar;
```

And the second component is the `NotificationModal` which is what gets displayed when the user clicks on the bell icon.

<Note>
  The beauty of using the headless version of the notification center is that you can customise exactly how it looks and which functionalities you need in it.
</Note>

Our `NotificationModal` component is as follows:

```javascript theme={null}
const NotificationModal = () => {

    const { notifications, markNotificationsAsRead, markAllMessagesAsRead, deleteNotification, setPageNum, pageNum, fetchNotifications } = useNotification();

    const handleNotificationRead = (notificationId) => {
        markNotificationsAsRead(notificationId);
    }

    const handleNotificationDelete = (notificationId) => {
        let newClass = document.getElementById(`${notificationId}`);
        newClass.style.display = 'none';
        deleteNotification(notificationId);
    }

    const handleMarkAllAsRead = () => {
        markAllMessagesAsRead();
    }
    const onPrvHandler = () => {
        setPageNum((prv) => prv - 1)

    }
    const onNxtHandler = () => {
        setPageNum((prv) => prv + 1)

    }


    useEffect(() => {
        fetchNotifications();
    }, [pageNum, fetchNotifications])
    return (
        <div className='bell-container'>
            <div className='heading'>
                <div className='title'>
                    <h2>
                        Notifications
                    </h2>
                </div>
                <div className='control-btn'>
                    <button className='modal-btn all-read title-btn' onClick={handleMarkAllAsRead}>Mark all as read</button>
                    <button className={` ${pageNum === 0 ? '' : 'modal-btn title-btn'}`} onClick={onPrvHandler} disabled={pageNum === 0 ? true : false}>Previous</button>
                    <button className={` ${notifications.length < 10 ? '' : 'modal-btn title-btn'}`} onClick={onNxtHandler} disabled={notifications.length < 10 ? true : false}>Next</button>
                </div>
            </div>
            <div>
                {notifications.map(not => (
                    <div key={not.id} className={`individual-notif`} id={`${not.id}`}>
                        <>
                            <span className={`bell-notif ${not.read ? 'read' : ''}`}>
                                {not?.payload?.description}
                            </span>
                            <div className='btn-container'>
                                {!not?.read && (
                                    <button onClick={() => handleNotificationRead(not?.id)} className='read-btn classic-btn'>Read</button>
                                )}
                                <button onClick={() => handleNotificationDelete(not?.id)} className='delete-btn classic-btn'>Delete</button>
                            </div>
                        </>
                    </div>
                ))
                }
            </div>
        </div>
    )
}
```

Finally, we've used some css to style the app to our liking. You can see that [here.](https://github.com/novuhq/novu-headless-demo-app/tree/main/frontend/src/styles).

## Conclusion

If you've followed everything till here, you'll end up with an app like the following:

<Frame>
  <img />
</Frame>

Again, don't forget that you can view the entire code [here](https://github.com/novuhq/novu-headless-demo-app/tree/main) and if you've any questions, either related to this headless app or something else, feel free to ping use [here.](https://discord.gg/novu)
Also, we've several demo apps for you to check out [here.](/demos/introduction)
Thanks for reading!


# How To Integrate Segment With Novu
Source: https://v0.x-docs.novu.co/guides/how-to-integrate-segment-with-novu



[Segment](https://segment.com/) is a customer data platform that helps businesses collect, manage, and analyze customer data from multiple sources. It streamlines data integration, ensures data quality, and aids in compliance with regulations. Segment's tools enable better understanding of customer behavior and facilitate personalized customer experiences. It's useful for marketing, analytics, and product teams in diverse industries.

If this is your first time working with the tool, consider consulting the 'Get Started' guide in [Segment's official documentation](https://segment.com/docs/getting-started/).

## Examples Use Case

**Enhancing Customer Engagement and Conversion Rates**

<Steps>
  <Step title="Data Integration with Segment">
    * The e-commerce platform uses Segment to collect and unify customer data from various sources like website visits, purchase history, and customer interactions.
    * Segment helps in creating a unified customer profile by consolidating data from different touchpoints – mobile app usage, website browsing patterns, and previous purchase behavior.

    <iframe title="YouTube video player" />
  </Step>

  <Step title="Behavioral Analysis and Segmentation">
    * The data collected is analyzed to understand customer preferences, buying patterns, and engagement levels.
    * Customers are segmented into different groups based on their behavior, interests, and purchase history. For instance, one segment might include frequent shoppers, while another might focus on those who browse but rarely purchase.

    <iframe title="YouTube video player" />
  </Step>

  <Step title="Personalized Notification with Novu">
    * Novu is used to craft and send personalized notifications to these segmented groups.
    * For frequent shoppers, notifications about new arrivals or exclusive deals might be sent. For those who browse but rarely buy, notifications could include special discount codes or reminders about items left in the cart.

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Trigger-Based Notifications">
    * Notifications can also be triggered based on specific customer actions. For example, if a customer views a product but doesn't make a purchase, they might receive a notification later highlighting a special offer on that product.

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Feedback Loop for Continuous Improvement">
    * Customer responses to these notifications are fed back into Segment. This data is used to refine customer profiles and segmentation strategies continuously.
    * The effectiveness of different types of notifications is analyzed to optimize future communication.
  </Step>
</Steps>

**Outcome:**

* Enhanced customer engagement through personalized and timely notifications.

* Improved conversion rates by targeting customers with relevant offers based on their behavior and preferences.

* Greater customer loyalty due to a tailored shopping experience.

## Setting Novu as a Destination

As of <Tooltip>today</Tooltip> Segment doesn’t have a native Novu Destination integration **yet** .

We will be using [Destination Functions](https://segment.com/docs/connections/functions/destination-functions/). Destination functions allow you to transform and annotate your Segment events and send them to any external tool or API without worrying about setting up or maintaining any infrastructure.

### Create a destination function

* From your workspace, go to `Connections > Catalog` and click the `Functions` tab.
* Click `New Function`.
* Select `Destination` as the function type and click `Build`.
* After you click `Build`, a code editor appears. Use the editor to write the code for your function, configure settings, and test the function’s behavior.

<Tip>Want to see some example functions? Check out the templates available in the Functions UI, or in the open-source Segment Functions Library.</Tip>

### Code the destination function

Segment invokes a separate part of the function (called a “handler”) for each event type that you send to your destination function.

<Note> Your function isn’t invoked for an event if you’ve configured a destination filter, and the event doesn’t pass the filter. </Note>

The default source code template includes handlers for all event types. You don’t need to implement all of them - just use the ones you need, and skip the ones you don’t.

Destination functions can define handlers for each message type in the Segment spec:

* onIdentify
* onTrack
* onPage
* onScreen
* onGroup
* onAlias
* onDelete
* onBatch

Each of the functions above accepts two arguments:

`event` - Segment event object, where fields and values depend on the event type.
For example, in “Identify” events, Segment formats the object to match the Identify spec.

`settings` - Set of settings for this function.
The example below shows a destination function that listens for “Track” events, and sends some details about them to an external service.

```javascript theme={null}
async function onTrack(event) {
  await fetch('https://example-service.com/api', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      event_name: event.event,
      event_properties: event.properties,
      timestamp: event.timestamp
    })
  })
}
```

To change which event type the handler listens to, you can rename it to the name of the message type.

For example, if you rename this function `onIdentify`, it listens for “Identify” events instead.

<Tip>
  If you you need an example of Novu destination function, you can find it in [here](https://github.com/novuhq/segment-novu-destination-scripts).
  Feel free to submit your function examples as well!
</Tip>

### Sending a payload to Novu

Now let's learn how to send a payload to Novu based on the `onTrack` event function:

To successfully send a payload to Novu, triggering the appropriate [workflow](/getting-started/concepts#workflow) and delivering it to the correct customer, please ensure that you provide the following information:

1. Novu's Workflow Identifier.
2. Subscriber ID (Please ensure that the Subscriber ID is both unique and consistent across all of your databases).
3. Your Novu API Key.
4. [Novu's Event Trigger API Endpoint](https://api.novu.co/events/trigger)

```javascript theme={null}
async function onTrack(event, settings) {
	const eventProperties = event.properties;

	if (!eventProperties.environment) {
		throw new InvalidEventPayload('environment property is required');
	}
	if (!eventProperties.name) {
		throw new InvalidEventPayload('Workflow name property is required');
	}

	console.log('environment:', eventProperties.environment);

	const payload = {
		name: eventProperties.name,
		to: {
			subscriberId: eventProperties.user.subscriberId,
			email: eventProperties.user.email,
			firstName: eventProperties.user.firstName,
			lastName: eventProperties.user.lastName
		},
		payload: { eventProperties }
	};
	const endpoint = settings.novuEndpoint;
	console.log('endpoint:', endpoint);

	const ApiKey = settings.novuApiKey; // Your NOVU API key
	if (eventProperties.environment === settings.environment) {
		let response;
		try {
			response = await fetch(endpoint, {
				method: 'POST',
				headers: {
					Authorization: `ApiKey ${ApiKey}`,
					'Content-Type': 'application/json'
				},
				body: JSON.stringify(payload)
			});
		} catch (error) {
			// Retry on connection error
			throw new RetryError(error.message);
		}
		if (response.status >= 500 || response.status === 429) {
			// Retry on 5xx (server errors) and 429s (rate limits)
			throw new RetryError(`Failed with ${response.status}`);
		}
	}
}
```

#### Create Settings and Secrets

Segment's settings allow you to pass configurable variables to your function, which is the best way to pass sensitive information such as security tokens. For example, you might use settings as placeholders to use information such as an API endpoint and API key.
You can learn more about it [here](https://segment.com/docs/connections/functions/destination-functions/#create-settings-and-secrets).

<Frame>
  <img />
</Frame>

Click `Add Setting` to add your new setting.

<Frame>
  <img />
</Frame>

Now, while configuring the function, Add these three variables to be then used in the code exposed in the settings function param.

<Frame>
  <img />
</Frame>

#### Test the destination function

You can test your code directly from the editor in two ways:

**1. Use sample events for testing**
Click `Use Sample Event` and select the source to use events from.

<Frame>
  <img />
</Frame>

Click `Run` to test your function with the event you selected.

**2. Test using manual input**
You can also manually include your own JSON payload of a Segment event, instead of fetching a sample from one of your workspace sources.

<Frame>
  <img />
</Frame>

**Here is the the event example JSON we will use**

```JSON theme={null}
{
  "type": "track",
  "event": "User Abandoned Cart",
  "properties": {
    "name": "abandoned-cart-recovery-workflow",
    "user": {
      "subscriberId": "63da8ee0c037e013fd790ffd",
      "email": "hi@hi.com",
      "firstName": "John",
      "lastName": "Doe"
    },
    "environment": "development"
  }
}
```

We will now execute the function based on the manual event input we've provided. This function sends a trigger to Novu, prompting to take action and send the user an email to return and the purchase.

<Frame>
  <img />
</Frame>

Whether you chose the first or second option to test your Destination Function, you can also check if the function triggered your workflow and whether it was delivered through Novu's [Activity Feed](https://web.novu.co/activities?utm_campaign=docs-guides-segment).

<Frame>
  <img />
</Frame>

This guide was inspired by the following resources:

* [https://discord.com/channels/895029566685462578/1060308007658987571/1077377322547687475](https://discord.com/channels/895029566685462578/1060308007658987571/1077377322547687475)
* [https://segment.com/docs/getting-started/05-data-to-destinations/](https://segment.com/docs/getting-started/05-data-to-destinations/)
* [https://aviyel.com/post/3381/how-to-integrate-novu-with-segment](https://aviyel.com/post/3381/how-to-integrate-novu-with-segment)


# How to send push notifications in an Android app (react native) with FCM and Novu
Source: https://v0.x-docs.novu.co/guides/novu-fcm-react-native-android

Learn how to send FCM push notifications in a React native Android app using Novu and FCM

## Prerequisites

To complete this tutorial, you will need the following:

* A [Firebase](https://firebase.google.com/) account
* A [Novu](https://web.novu.co/?utm_campaign=docs-gs-guides-fcm-android) account
* An [Expo](https://expo.dev) account

Push notifications are notifications that are sent to a user’s devices whether the user is using the app or not. We’ll be using the Firebase Cloud Messaging (FCM) integration of Novu to send these notifications. You can find the complete code for this project in our [Github repo.](https://github.com/novuhq/fcm-react-native-android)

## Start a React-Native project

We'll use the `create-expo` tool to initialize a new expo app. It creates a new React Native app with the expo package installed. We're naming our app `fcm-novu-rn2` and hence using the following command:

```javascript theme={null}
 npx create-expo-app fcm-novu-rn2
```

<Info>If it asks you to choose a template, choose the 'blank' template.</Info>

Now, go to the project directory and install the `react-native-firebase` package using the following command:

```bash theme={null}
npm install --save @react-native-firebase/app
```

Once this is installed, install the messaging module of Firebase using the following command:

```bash theme={null}
npm i --save @react-native-firebase/messaging
```

## Getting the FCM token

Now, we need to grab the `token key` from FCM. We'll need this to send notifications using FCM. We're using `useEffect` to grab this key as follows:

```jsx theme={null}
// import messaging module
import messaging from '@react-native-firebase/messaging';

// Request permission to send notifications
const authStatus = await messaging().requestPermission();

// Check if permission is granted or provisional
const enabled =
  authStatus === messaging.AuthorizationStatus.AUTHORIZED ||
  authStatus === messaging.AuthorizationStatus.PROVISIONAL;

// If permission is granted or provisional, proceed
if (enabled) {
  // Log the authorization status
  console.log('Authorization status:', authStatus);

  // Retrieve the FCM token for the device
  const token = await messaging().getToken();
  // Log the FCM token
  console.log('FCM Token is:', token);

  // Return a function to unsubscribe from notifications
  return unsubscribe;
} else {
  // If permission is not granted, log the error status
  console.log('Could not grab token...', authStatus);
}

```

## FCM handlers

FCM uses something called a `background handler` to, as the name suggests handle notifications when the app is in the background. So, we'll add it to our app:

```jsx theme={null}
// Background message handler for incoming messages while the app is in bg
messaging().setBackgroundMessageHandler(async (remoteMessage) => {
  // Log a message indicating that a message was handled in the background
  console.log('Message handled in the background!', remoteMessage);
});

```

Similarly, we also need a `foreground handler` to handle notifications when the app is in the foreground. In our case, we're updating a state's value in our handler. Here's our foreground handler:

```jsx theme={null}
// handle incoming messages while the app is in the foreground
const unsubscribe = messaging().onMessage(async (remoteMessage) => {
  // Log a message indicating that the onMessage event is working
  console.log('working!!!!');
  
  // Update state with the received message
  setNotification(remoteMessage);
});
return unsubscribe;
```

## Setting up Expo

In order to load projects from Expo CLI, we need a dev client to be installed in our app. To install it, execute the following command from the root of the project directory:

```bash theme={null}
 npx expo install expo-dev-client
```

Once installed, log into your expo account using the following command:

```bash theme={null}
eas login
```

It'll ask for your username and password and log you in.

Now, we are ready to create our build of the app. Use the following command to create a development build of the app for the Android platform:

```bash theme={null}
eas build --profile development --platform android
```

<Info>If expo asks if you want to automatically create an EAS project for your app, choose yes. Do the same when it asks you if you want to generate a new keystore.</Info>
<Warning>Do not change the Android package name, even if EAS asks you to!</Warning>

## Setting up Firebase

1. Create a Firebase account if you don't already have one. Then, create a new project and all the relevant details.

<Frame>
  <img />
</Frame>

2. Once your project has been created, you'll be greeted with this welcome screen and asked to add Firebase to your app, so let's do that.

<Frame>
  <img />
</Frame>

3. We'll choose the 'Android' option because we're creating an Android app.

<Frame>
  <img />
</Frame>

4. Find the package name from the `app.json` file of the project:

<Frame>
  <img />
</Frame>

5. Add this package name to Firebase:

<Frame>
  <img />
</Frame>

6. Now, we need to add `SHA1` keys from our project to the Firebase app. Run the following command to obtain `SHA1` key. We'll get two `SHA1` keys, one of which we'll add to Firebase right now and the other one, later on.

```bash theme={null}
eas credentials
```

<Info>If it asks you to, choose the 'Android' platform then 'Development' build then 'Keystore' then 'Set up a new keystore' then 'Select Build Credentials' and then 'Create a new build credential configuration'.</Info>

<Frame>
  <img />
</Frame>

7. Now copy the `SHA1` key and add it to Firebase and register the app:

<Frame>
  <img />
</Frame>

8. Click 'next' on all the other options and finally click 'continue to console' as follows:

<Frame>
  <img />
</Frame>

9. Go to 'project settings' and scroll all the way down

<Frame>
  <img />
</Frame>

10. Click on the 'Add fingerprint' button and add the second `SHA1` key here.

<Frame>
  <img />
</Frame>

11. Now, download the Google services file and add it to the project's root directory. We also need to specify its location in the `app.json` file:

<Frame>
  <img />
</Frame>

12. Now we need to upload the Firebase server key to expo. Go to project settings and find it under the 'Cloud Messaging' tab.

<Frame>
  <img />
</Frame>

13. Now, upload that key to expo using the following command:

```bash theme={null}
expo push:android:upload --api-key <your server key here> 
```

14. Rebuild the app using the following command and we're good to go!

```bash theme={null}
eas build --profile development --platform android
```

15. If you have an Android device with you, simply scan and install the app. Otherwise, if you want to run it on an emulator, simply copy the link given alongside the QR code and open it on the emulator and then install the app.

16. Start the server to run the app, using the following command:

```bash theme={null}
npx expo start --dev-client
```

Again, you can either scan the QR code or copy and paste the link.

<Frame>
  <img />
</Frame>

<Warning>Sometimes it doesn't fire up the emulator even when you have it installed. In that case, start the emulator manually and run the server again!</Warning>

## Setting up Novu

We'll need a workflow to trigger notifications to our user's devices. Follow the steps below to create one to ensure we are on the path to making FCM work as expected:

1. Head over to the [Integrations Store](https://web.novu.co/integrations?utm_campaign=docs-guides-fcm-android) on the Novu Web Dashboard and make sure that you've turned on the 'Firebase Cloud Messaging' integration.

<Frame>
  <img />
</Frame>

<Info>If you're doing this for the first time, you'll need to get your service account key from the [Firebase Console](https://console.firebase.google.com/). Read more about it in our [FCM provider docs.](https://docs.novu.co/channels-and-providers/push/fcm)</Info>
2\. Now, we need to create a workflow that we'll trigger from our app to send notifications. Head over to [workflows in the Novu Web Dashboard](https://web.novu.co/workflows?utm_campaign=docs-guides-fcm-android) and click on the 'Add a workflow' button.

<Frame>
  <img />
</Frame>

3. Choose the 'blank workflow' option from the dropdown menu.

<Frame>
  <img />
</Frame>

3. Drag and drop the 'Push' node below the Workflow Trigger node.

<Frame>
  <img />
</Frame>

4. If you hover over the newly added 'Push' node, you'll see an error saying 'Message content and title are missing'.

<Frame>
  <img />
</Frame>

5. We're going to add a title and body for notifications. So, add them and give your workflow a suitable name.

<Frame>
  <img />
</Frame>

6. Now, click on the 'Update' and then the 'get snippet' button to get the trigger code.

<Frame>
  <img />
</Frame>

## Create a subscriber and update credentials

A subscriber is essentially the recipient of the notifications sent through Novu’s system. When you create a subscriber, you’re setting up the necessary information for Novu to send targeted notifications to. You can find more about subscribers in [our docs.](https://docs.novu.co/subscribers/subscribers)
To create a subscriber, we'll use the `identify` method:

```jsx theme={null}
// creating new instance of Novu
const novu = new Novu("<Novu API key>");

// creating subscriber
await novu.subscribers.identify('newSubForRNA', {
    firstName: "RNA"
});
```

Now, we'll add the FCM token that we'd received [earlier](#getting-the-fcm-token) to this subscriber using the `setCredentials` method:

```jsx theme={null}
await novu.subscribers.setCredentials('newSubForRNA', PushProviderIdEnum.FCM, {
    deviceTokens: ['<Enter the FCM token here>'],
});
// notice the use of 'newSubForRNA' here. This identifies the subscriber to which we're adding the FCM token
```

## Sending a push notification using Novu

To send a notification with Novu, we are actually triggering a notification workflow. Here's how to do it using Node:

```jsx theme={null}
novu.trigger('rna-2', {
    to: {
        subscriberId: 'newSubForRNA'
    },
    payload: {},
})
```

When triggered using the trigger code from above, this is the notification received on the device:

<Frame>
  <img />
</Frame>

## Dynamic content

So far, we've sent notifications that have had "hard-coded" content. Now we'll send dynamic data when triggering a notification.

The way to do so is by changing the values of the title and the body to `{{title}}` and `{{body}}` in our workflow.

1. Go to the workflow we'd created earlier and change the values of the title and the body to `{{title}}` and `{{body}}` respectively.

<Frame>
  <img />
</Frame>

2. Simply add these identifiers to the payload by changing the trigger code:

```jsx theme={null}
novu.trigger('rna-2', {
    to: {
        subscriberId: 'newSubForRNA'
    },
    payload: {
        title: payloadTitle,
        body: payloadBody
    },
});
```

<Note>We're extracting `payloadTitle` and `payloadBody` from the request body</Note>
Now, the notification delivered to the subscriber will contain dynamic data as shown below:

<Frame>
  <img />
</Frame>

## Sending images

Up to this point, your notifications have all contained only text. But if you’ve received many notifications, you know that notifications can have rich content, such as images. It’d be great if your notifications showed users a nice image related to their content. Once again, Firebase makes this super simple.

All you need to do is to specify the `URL` of the image in the override as shown below:

```jsx theme={null}
novu.trigger('rna-2', {
    to: {
        subscriberId: 'newSubForRNA'
    },
    payload: {
        title: payloadTitle,
        body: payloadBody
    },
    overrides: {
        fcm: {
            android: {
                notification: {
                    imageUrl: 'URL of the image',
                }
            }
        }
    }
});
```

The following notification is what gets delivered to the subscriber:

<Frame>
  <img />
</Frame>

## Handling data type messages

With FCM, you can send `Notification` and `Data` messages. We have handled sending notification messages. Let’s handle data messages. Data type messages are useful when, in addition to the usual data, you want to send some custom data. Maybe whether a subscriber has purchased the pro plan of our product or not, maybe which tier of usage they have purchased etc. You can do this easily by modifying the override. Here's an example of sending the subscription status using the identifier `subStatus`:

```jsx theme={null}
novu.trigger('rna-2', {
    to: {
        subscriberId: 'newSubForRNA'
    },
    payload: {
        title: payloadTitle,
        body: payloadBody
    },
    overrides: {
        fcm: {
            android: {
                    data: {
                        subStatus: "true"
                    },
            }
        }
    }
});
```

On the user's device, you can extract this out and have it displayed like this:

<Frame>
  <img />
</Frame>

## Priority of a notification

FCM tries to deliver high-priority messages immediately. The priority of a notification can also be altered by changing the overrides, as shown below:

```jsx theme={null}
novu.trigger('rna-2', {
    to: {
        subscriberId: 'newSubForRNA'
    },
    payload: {
        title: payloadTitle,
        body: payloadBody
    },
    overrides: {
        fcm: {
            android: {
                    data: {
                        subStatus: "true"
                    },
                    notification: {
                        priority: 'low'
                    }
            }
        }
    }
});
```

<Frame>
  <img />
</Frame>

## Additional resources

* [Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging)
* [FCM Architectural Overview](https://firebase.google.com/docs/cloud-messaging/fcm-architecture)


# How to send web push notifications with FCM and Novu
Source: https://v0.x-docs.novu.co/guides/novu-fcm-web

Send FCM push notifications in a React app using Novu

## Introduction

In this guide, we'll learn how to send FCM push notifications in a web app using Novu. But before exploring the actual code, let’s understand what a push notification is and how it works.
You can find the [frontend code](https://github.com/novuhq/fcmWebPushFE) as well as [backend code](https://github.com/novuhq/FCMWebPushBE) for the app on Github.

<br />

Push notifications are notifications that are sent to a user's devices whether the user is using the app or not. We'll be using Firebase Cloud Messaging (FCM) integration of Novu to send these notifications. This guide will be broken down into three parts:

1. Setting up Novu.
2. Setting up Firebase.
3. Adding Firebase to the Frontend.
4. Adding Novu to the Backend.

## Setting up Firebase

1. Create a Firebase account if you don't already have one. Then, create a new project and all the relevant details.

<Frame>
  <img />
</Frame>

2. Once your project has been created, you'll be greeted with this welcome screen and asked to add Firebase to your app, so let's do that.

<Frame>
  <img />
</Frame>

3. We'll choose the web option because we're creating a web app.

<Frame>
  <img />
</Frame>

4. Give your app a name and click on the 'Register' button.

<Frame>
  <img />
</Frame>

5. We're done with the Firebase setup! Now, we'll set up Novu and finally proceed to add both (Novu and FCM) to our app.

## Setting up Novu

We'll need a workflow to trigger notifications to our user's devices. Follow the steps below to create one to ensure we are on the path to make FCM work as expected:

1. Head over to the [Integrations Store](https://web.novu.co/integrations?utm_campaign=docs-guides-fcm-web) on the Novu Web Dashboard and make sure that you've turned on the 'Firebase Cloud Messaging' integration.

<Frame>
  <img />
</Frame>

<Info>If you're doing this for the first time, you'll need to get your service account key from the [Firebase Console](https://console.firebase.google.com/). Read more about it in our [FCM provider docs.](https://docs.novu.co/channels-and-providers/push/fcm)</Info>
2\. Now, we need to create a workflow that we'll trigger from our app to send notifications. Head over to [workflows in the Novu Web Dashboard](https://web.novu.co/workflows?utm_campaign=docs-guides-fcm-web) and click on the 'Add a workflow' button.

<Frame>
  <img />
</Frame>

3. Choose the 'blank workflow' option from the dropdown menu.

<Frame>
  <img />
</Frame>

3. Drag and drop the 'Push' node below the Workflow Trigger node.

<Frame>
  <img />
</Frame>

4. If you hover over the newly added 'Push' node, you'll see an error saying 'Message content and title are missing'.

<Frame>
  <img />
</Frame>

5. We're going to use the identifiers `title` and `body` for the title and the content of notifications, so let's add them in the 'Push message title' and the 'Push message content' fields respectively. So, add them and give your workflow a suitable name.

<Frame>
  <img />
</Frame>

6. Now, click on the 'get snippet' button to get the trigger code.

<Frame>
  <img />
</Frame>

## Adding Firebase to the frontend

1. In your project, add Firebase using the following command:

```bash theme={null}
npm install firebase
```

2. Create a new file called `firebase.js` and add the following to it:

```jsx theme={null}
import { initializeApp } from "firebase/app";
import { getMessaging, onMessage } from "firebase/messaging";

//from firebase console
// Your web app's Firebase configuration
const firebaseConfig = {
    apiKey: import.meta.env.VITE_FIREBASE_API_KEY,
    authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN,
    projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID,
    storageBucket: import.meta.env.VITE_FIREBASE_STORAGE_BUCKET,
    messagingSenderId: import.meta.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
    appId: import.meta.env.VITE_FIREBASE_APP_ID,
};

// Initialize Firebase
export const app = initializeApp(firebaseConfig);

// Initialize Firebase Cloud Messaging and get a reference to the service
export const messaging = getMessaging(app);

export const onMessageListener = () =>
    new Promise((resolve) => {
        onMessage(messaging, (payload) => {
            console.log("payload", payload)
            resolve(payload);
        });
    });
```

3. Now, we need to generate tokens using the `getToken` method provided by Firebase. But we want to use this only when the user has allowed notifications on their end. So let's request notification permission from the user and if granted, we'll generate the token. Add this to your root module:

```jsx theme={null}
 async function requestPermission() {
    const permission = await Notification.requestPermission()
    if (permission === 'granted') {
      // get token
      const token = await getToken(messaging, { vapidkey: import.meta.env.VITE_VAPID_KEY })
    } else if (permission === 'denied') {
      alert('Persmission denied!')
    }
  }
  useEffect(() => {
    requestPermission();
  }, [])
```

4. To use the `getToken` method, you need a Voluntary Application Server Identification or `VAPID key`. Go to your Project Settings -> Cloud Messaging -> Generate key pair (under Web Push Certificates):

<Frame>
  <img />
</Frame>

5. In order for Firebase's background listener service to work, you need a service worker. Make sure you've created a service worker file `firebase-messaging-sw.js` and add the following to it:

```jsx theme={null}
importScripts("https://www.gstatic.com/firebasejs/8.10.0/firebase-app.js");
importScripts(
    "https://www.gstatic.com/firebasejs/8.10.0/firebase-messaging.js"
);

const firebaseConfig = {
    apiKey: import.meta.env.VITE_FIREBASE_API_KEY,
    authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN,
    projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID,
    storageBucket: import.meta.env.VITE_FIREBASE_STORAGE_BUCKET,
    messagingSenderId: import.meta.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
    appId: import.meta.env.VITE_FIREBASE_APP_ID,
};

firebase.initializeApp(firebaseConfig);
const messaging = firebase.messaging();
messaging.onBackgroundMessage((payload) => {
    console.log(
        "notif incoming",
        payload
    );
    const notificationTitle = JSON.parse(JSON.parse(payload.notification)).title
    // payload.notification.title;
    const notificationOptions = {
        body: payload.notification.body,
        icon: payload.notification.image,
    };

    self.registration.showNotification(notificationTitle, notificationOptions);
});


```

## Adding Novu to the backend

In your app's backend, add Novu using the following command:

```bash theme={null}
npm install @novu/node
```

Now, create a route that you want to hit when called from the front end. In our app, this is the route:

```jsx theme={null}
import express from "express";
import { createNotif } from '../controller/notif.js'

const router = express.Router();

router.post('/create', createNotif)

export default router;
```

Now, we need a controller function to handle the logic for what is to be sent in the trigger function’s payload. In our case, this is the controller function:

```jsx theme={null}
import { inAppNotification } from "../novu/novu.js";

export const createNotif = async (req, res) => {

    const { title, body } = req.body
    try {
        await inAppNotification(title, body);
        res.status(201).json({ message: 'success', title: title, body: body });
    } catch (error) {
        res.status(409).json({ message: error.message });
    }
}
```

To make it modular, we’ll keep the trigger code in a separate function in a separate file (`novu.js`, in our case) and the trigger function is getting called in the controller function above by the name `createNotif`.

If you’re following the guide, you should already have the trigger function. But before we can add it to our app, we need one key thing - **Subscribers.**

[Subscribers](https://docs.novu.co/subscribers/subscribers) are entities to which the notifications are sent. You can see a list of subscribers in the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-guides-fcm-web) as well.

We'll create a subscriber in our app. Our backend will be written in Node.js, but we also have backend [SDKs in PHP, .NET, Go, Ruby, Python, and Kotlin](/sdks/introduction). The recommended way to create a subscriber in NodeJS is as follows:

```jsx theme={null}
 await novu.subscribers.identify(process.env.NOVU_SUB_ID, {
        firstName: "pushSubscriber"
    });
```

Here, we're creating a subscriber with the `subscriberID` of whatever value the `env` file contains for the identifier `NOVU_SUB_ID`. You can read more about subscribers [in our docs.](/subscribers/subscribers).

Back in our app, before we can now add the trigger function, we need to set device identifiers using the [setCredential method](https://docs.novu.co/channels-and-providers/push/fcm#set-device-token):

```jsx theme={null}
await novu.subscribers.setCredentials(process.env.NOVU_SUB_ID, PushProviderIdEnum.FCM, {
        deviceTokens: [process.env.DEVICE_TOKEN],
    });
```

<Info>You'll need to pass the `subscriberID` and the `deviceTokens` in the `setCredentials` method.</Info>

Finally, we can add the trigger code:

```jsx theme={null}
import { Novu, PushProviderIdEnum } from '@novu/node';

export const inAppNotification = async (title, body) => {

    const novu = new Novu(process.env.NOVU_API_KEY);
    await novu.subscribers.identify(process.env.NOVU_SUB_ID, {
        firstName: "pushSubscriber"
    });

    await novu.subscribers.setCredentials(process.env.NOVU_SUB_ID, PushProviderIdEnum.FCM, {
        deviceTokens: [process.env.DEVICE_TOKEN],
    });

    novu.trigger(process.env.NOVU_WORKFLOW_ID, {
        to: {
            subscriberId: process.env.NOVU_SUB_ID
        },
        payload: {
            title: title,
            body: body
        },
    });
};
```

We're done with the app. You can find the [frontend code](https://github.com/novuhq/fcmWebPushFE) as well as [backend code](https://github.com/novuhq/FCMWebPushBE) for the app on Github.

Congratulations on following the guide up until this point. If you’ve done everything as recommended, you’ll end up with an app that uses Firebase Cloud Messaging to send notifications to your users using Novu.


# How to use Novu to send notifications to a Slack channel
Source: https://v0.x-docs.novu.co/guides/slack-guide

Learn to send Slack notifications swiftly with Novu (manually managed)

# Introduction

In this guide, you'll learn how to use Novu to send notifications directly to a Slack channel. But before coding anything up, we first need to go through a setup process.
The corresponding docs for this guide are available on our [docs](https://docs.novu.co/channels-and-providers/chat/slack).
<Note>The entire code of this app (frontend as well as backend) can be found [here](https://github.com/novuhq/slack-app).</Note>

So let's begin!

# Create a Slack App

Creating a Slack app is fairly simple. Follow these steps to create your app:

1. Go to [Slack's app dashboard](https://api.slack.com/apps) and click on the 'Create new App' button, as shown in the image:

<Frame>
  <img />
</Frame>

2. Choose 'From Scratch' from the following dialog:

<Frame>
  <img />
</Frame>

3. Choose a name for your app and select the Slack workspace in which you want to send notifications:

<Frame>
  <img />
</Frame>

4. Once you're done, simply click the 'Create App' button:

<Frame>
  <img />
</Frame>

5. Once done, you'll be greeted with the screen shown below. We'll make a couple of changes here and it'll be ready to go.

<Frame>
  <img />
</Frame>

6. We'll need `Client Id` from the [Slack Developer's Dashboard](https://api.slack.com/apps) for configuring Slack Integration in the [Novu Web Dashboard](https://web.novu.co/integrations?utm_campaign=docs-guides-slack) later, so keep it handy.

<Frame>
  <img />
</Frame>

# Create a workflow in the Novu Web Dashboard

1. To create a workflow, head to the workflow section in the [Novu Web Dashboard](https://web.novu.co/workflows?utm_campaign=docs-guides-slack).
2. Click on the 'Add a workflow' button and select 'Blank workflow' from the dropdown.

<Frame>
  <img />
</Frame>

3. Once there, give your workflow a name and drag and drop the 'chat' option below the 'workflow trigger' step.

<Frame>
  <img />
</Frame>

4. You can also add variables in the Workflow Editor. For example, here I've added 'chatMsg' as a variable as I'll be sending data using it.

<Frame>
  <img />
</Frame>

<Info>Whatever is placed inside double braces is a variable.</Info>
5\. Make sure that you've turned on the Slack integration in the [Integrations Store](https://web.novu.co/integrations?utm_campaign=docs-guides-slack).

<Frame>
  <img />
</Frame>

6. To turn the Slack integration on, you'll need `Client Id`. You should have it already but if you don't, you can obtain it from the [Slack Developer's Dashboard](https://api.slack.com/apps).

<Frame>
  <img />
</Frame>

7. Once you have it, you need to plug it into the respective field in the [Slack Integration Settings](https://web.novu.co/integrations?utm_campaign=docs-guides-slack) on the Novu Web Dashboard.

<Frame>
  <img />
</Frame>

# Create the backend

The backend for this app is quite simple. Simply install the Novu package:

```bash theme={null}
npm install @novu/node

```

Now, create a route that you'll hit when called from the front end. We'll also need to add it to our Slack app (discussed below). For our demo app, this is the route I've created:

```jsx theme={null}
import express from "express";
import { chatController } from "../controller/chat.js";

const router = express.Router();

router.post("/sendChat", chatController);

export default router;
```

Now, we need a controller function to handle what is to be sent in the trigger's function payload. Here's the controller I wrote:

```jsx theme={null}
import { chat } from "../novu/novu.js"

export const chatController = async (req, res) => {
    const { chatMsg } = req.body;
    try {
        await chat(chatMsg);
        res.status(201).json({ message: "Message sent successfully" });
    } catch (error) {
        res.status(500).json({ message: error.message })
    }
}
```

<Info>Notice how we're expecting 'chatMsg' in our payload. This is why we added it as a variable in the workflow created earlier.</Info>

To make it modular, we’ll keep the trigger code in a separate function in a separate file, `novu.js`, in our case, which is as follows:

```jsx theme={null}
import { Novu, ChatProviderIdEnum } from '@novu/node';

export const chat = async (chatMsg) => {
    const novu = new Novu(process.env.YOUR_NOVU_API_KEY_HERE);
    await novu.subscribers.identify(process.env.SUB_ID, {
        firstName: 'newSubForSlackChat',
    });

    await novu.trigger('slack', {
        to: {
            subscriberId: process.env.SUB_ID
        },
        payload: {
            chatMsg: chatMsg
        }
    });
}
```

In this code snippet above, we're first initializing a new instance of Novu, then using it to 'identify' or [create](https://docs.novu.co/subscribers/subscribers#create-a-subscriber) a [subscriber](https://docs.novu.co/subscribers/subscribers).
<Info>The 'identify' method tries to find a subscriber with the given info. If it can't find any such subscriber, it creates a new subscriber with the supplied info.</Info>
After creating the subscriber, it runs the trigger code for the workflow we had created. You can find the trigger workflow by clicking on the 'Get Snippet' button on the workflow:

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

# Configure the Slack app

There are two ways to configure the Slack app. One is the Novu managed option and another the manually managed option.
Since the Novu managed is fairly straightforward, I'll demonstrate the manual method here. Follow along to set it up!

1. Goto 'Incoming Webhooks' in your Slack app settings and turn it on.

<Frame>
  <img />
</Frame>

2. Click on the 'Add New Webhook to Workspace':

<Frame>
  <img />
</Frame>

3. Now, go ahead and select the channel in which you want to send notifications and click 'allow'.

<Frame>
  <img />
</Frame>

4. Then, copy the 'webhookUrl' from Slack.

<Frame>
  <img />
</Frame>

5. Now, add the code below to the backend trigger functionality. Using this code, we are specifying what `webhookUrl` Novu will use to authenticate when using the Slack provider.

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Slack, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "slack",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "slack-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

In our case, we'll add it to the `Novu.js` file we created earlier so that the final file becomes :

```jsx theme={null}
import { Novu, ChatProviderIdEnum } from '@novu/node';

export const chat = async (chatMsg) => {
    const novu = new Novu(process.env.YOUR_NOVU_API_KEY_HERE);
    await novu.subscribers.identify(process.env.SUB_ID, {
        firstName: 'newSubForSlackChat',
    });

    await novu.subscribers.setCredentials(process.env.SUB_ID, ChatProviderIdEnum.Slack, {
        webhookUrl: process.env.SLACK_WEBHOOK_URL,
    });

    await novu.trigger('slack', {
        to: {
            subscriberId: process.env.SUB_ID
        },
        payload: {
            chatMsg: chatMsg
        }
    });
}
```

6. Finally, we'll add the route we'd created earlier to the redirect URL section, as shown:

<Frame>
  <img />
</Frame>

<Info>For demonstration purposes, I've added both the local as well as the deployed URL. You only need one depending on whether you're running this locally or have a deployed version.</Info>
Now, our backend is all done, our Slack is all setup and all we need to do is hit the URL

# Front end set up

For our demonstration purposes, the front end is pretty basic. All we have to do is have an input field to take the notification text in and send the payload. The front end code for this demo app is available on our [Github repo](https://github.com/novuhq/slack-app/tree/main/frontend).
And here's our app in all its glory!

<Frame>
  <img />
</Frame>

This is how we send Slack notifications using Novu!


# Centralized multiple legacy implementations of different teams
Source: https://v0.x-docs.novu.co/guides/usecases/centralized-multiple-legacy-implementations

Learn to use Novu to centralize legacy notification implementations.

If you're coming from a medium or large team with multiple implementations of sending notifications across channels, then you can be rest assured that Novu will be the central gateway.

* Install Novu's SDK (according to your preferred tech).
* Connect your existing delivery providers to Novu.
* [Migrate your users to subscribers](/subscribers/subscribers#import-subscribers) on Novu either via Cloud or on-prem.
* Now, every notification fires via Novu.

Teams in charge of content can always update the workflow templates via the dashboard. Engineers can always debug and add as many providers or activate as many more channels needed!


# Debug notifications across channels in a single place
Source: https://v0.x-docs.novu.co/guides/usecases/debug-notifications

Understand the lifecycle of your notifications

Debugging notifications can be a hassle. Novu allows you understand and debug notifications sent across different channels in one place.

In [Novu's Activity Feed](https://web.novu.co/activities?utm_campaign=docs-usecases-debug), you can access a log of all the notifications that have been sent & filter through the successful & failed ones. Furthermore, you'll know why it failed!

You can filter through channels, workflows, emails, subscribers and transactions.

<Frame>
  <img />
</Frame>

<br />

<Frame>
  <img />
</Frame>

[Explore more about Novu’s Activity Feed](/activity-feed/introduction)


# Digest multiple events in a single notification
Source: https://v0.x-docs.novu.co/guides/usecases/digest-multiple-events

Learn to leverage Novu in digesting multiple events.

One of the recurring features developers yearn for is the ability to batch multiple notifications and send as one to subscribers.

Novu ships with a built-in digest engine that handles batching and digesting multiple events in a single notification. You can programmatically adjust the digest recurrence or set it from the dashboard.

<Frame>
  <img />
</Frame>

[Explore more about Novu's Digest Feature](/workflows/digest)


# Fully featured embedded notification center
Source: https://v0.x-docs.novu.co/guides/usecases/embedded-notification-center

A real-time fully functional embedded notification center

Novu provides a real-time embedded notification center widget that can simply be dropped into any web application.

<Frame>
  <img />
</Frame>

It's available as a drop-in component for React, Vue and Angular apps. For non-specific frameworks, it's also ready as a bundled web component.

We care about the developer experience so much that we also built a headless, zero-UI version to empower you to hand-craft your notification center.

[Explore a lot more about the Notification Center here](/notification-center/introduction)


# Learn by usecase
Source: https://v0.x-docs.novu.co/guides/usecases/introduction

Learn Novu's Use Cases

Novu is built to empower engineering teams in integrating rich product notification experiences seamlessly without re-inventing the wheel.

It has been thoroughly and beautifully crafted to help individuals, teams, businesses and organizations focus on what truly matters: creating exceptional user experiences and driving engagement through smooth and swift notifications delivery.

The common use cases for using Novu are highlighted below:

<CardGroup>
  <Card title="Managing multiple delivery providers in one place" icon="circle-1" href="/use-cases/multiple-delivery-providers" />

  <Card title="Fully featured embedded Notification Center" icon="circle-2" href="/use-cases/embedded-notification-center" />

  <Card title="Digest multiple events in a single notification" icon="circle-3" href="/use-cases/digest-multiple-events" />

  <Card title="Manage notification in multiple languages" icon="circle-4" href="/use-cases/manage-notifications-in-multiple-languages" />

  <Card title="Processing and sending notifications at any scale" icon="circle-5" href="/use-cases/send-notifications-at-any-scale" />

  <Card title="Centralized multiple legacy implementations of different teams" icon="circle-6" href="/use-cases/centralized-multiple-legacy-implementations" />

  <Card title="Debug notifications across channels and vendors in a singe place" icon="circle-7" href="/use-cases/debug-notifications" />
</CardGroup>


# Manage notifications in multiple languages
Source: https://v0.x-docs.novu.co/guides/usecases/manage-notifications-in-multiple-languages

Learn to send notifications in different languages effortlessly

This feature is currently under development. However if you urgently need this, [reach out to us for more information](https://notify.novu.co/meetings/novuhq/notifications-45min?utm_campaign=novuDocs\&utm_content=notifications-in-multiple-languages-docs).


# Managing multiple delivery providers in one place
Source: https://v0.x-docs.novu.co/guides/usecases/multiple-delivery-providers

Learn to manage many delivery providers across different channels in one dashboard

[Novu's dashboard](https://web.novu.co/integrations?utm_campaign=docs-usecases-multipledelivery) empowers you to manage all your notification delivery providers across Email, Sms, Push and Chat in one place.

You can activate, deactivate, modify settings, set primary and secondary active providers as you wish from the dashboard.

### Integrations Store

<Frame>
  <img />
</Frame>

### Add a new Delivery Provider

<Frame>
  <img />
</Frame>


# Processing and sending notifications at any scale
Source: https://v0.x-docs.novu.co/guides/usecases/send-notifications-at-any-scale

Novu can handle notifications at extremely large scale

[Novu's Cloud](https://web.novu.co?utm_campaign=docs-usecases-notificationsscale) is built to process and send notifications at any scale. For folks using the self-hosted Novu version, you can scale it up as your needs grow.

If you're looking to use Novu on a very large scale & you need to confirm infrastructure & scalability prowess, [please reach out to us for more information](https://notify.novu.co/meetings/novuhq/notifications-45min?utm_campaign=docs-bam-usecases-notificationsscale).


# Account Management
Source: https://v0.x-docs.novu.co/help/account-management



### Creating an account

Novu supports [US](https://web.novu.co/auth/signup?utm_campaign=docs-gs-help-account-mgmt) and [EU](https://eu.web.novu.co/auth/signup?utm_campaign=docs-gs-help-account-mgmt) regions based on where you want your data to be stored. In both the regions, a new account can be created using Github or Email and Password. If you are looking for other ways to signup on Novu, feel free to reach out us at [support@novu.co](mailto:support@novu.co).

### Resetting password

If you have created an account with Novu before, you can reset your password by clicking on `Forgot Your Password?` option on the sign-in page.

### Is US and EU account data synced?

US and EU accounts are completely independent. If you have created an account in the US, you will not be able to login with the same credentials in the EU and vice versa.

### Changing the email associated to my account

If you want to change your account email, please reach out to us at [support@novu.co](mailto:support@novu.co).

### What happens if I change my Github account email?

If you created your Novu account using Github, and you change your email in Github, it will not be reflected in Novu. When you login to Novu using the new Github email, a new account will be created. Please email [support@novu.co](mailto:support@novu.co) to update your email address.

### How do I create a new Organization?

A new organization can be created by writing something in the dropdown in the left bottom corner of the dashboard. As soon you start writing something, an add option will apear. This dropdown can also be used to switch between [organizations](/getting-started/concepts#organization). One organization's data is not visible to other organization members.

### How to change organization name?

We are working on account management feature currently so this option is not available in UI as of now. If you want to change your current organization name, [rename organization api](/api-reference/organizations/rename-organization) can be used. if you face any issue in using api or need any help any changing the organization name, please reach out to us at [support@novu.co](mailto:support@novu.co).

### How to upload multiple image assets similar to logo?

Currently, Novu supports uploading only one logo image per organization. If you want to use other images in workflow step content then a valid absolute url of image can be used with `<img>` tag.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Chat
Source: https://v0.x-docs.novu.co/help/channels/chat



### Can I send a message to a specific user on Slack?

While installing the Slack app, you will be asked the User or Channel to which the message needs to be sent. On selecting a user, a webhookUrl for that user will be generated and Novu will use that webhookUrl to send a message to that specific user.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Email
Source: https://v0.x-docs.novu.co/help/channels/email



### How to override default values of Email?

All values (from, to, subject, body, etc.) can be overridden by using the `overrides` option while triggering the workflow. Please see our [email overrides documentation](/channels-and-providers/email/overview#sending-email-overrides) for more details.

### Sending HTML as the value of a variable

HTML content as a value of step variable can be sent by replacing the double curly braces `{{}}` variable with triple curly braces `{{{}}}` variable. For example, `{{{htmlContent}}}`.

### I have multiple Email Providers or integrations active, how do I associate them to a Workflow?

There can be more than one active email integrations of same or different providers. However only one email integration can be primary at one time per environment. To use a different email integration than your primary integration, the integrationIdentifier field of email overrides can be used. Read about using [different email integration](/channels-and-providers/email/overview#using-different-email-integration) for more details.

### Why am I getting the error “message content could not be generated”?

This error occurs when the HTML content is not properly formatted. Make sure the HTML content is properly formatted and does not contain any syntax errors. Make sure Step Variables are properly formatted and are not missing opening or closing curly braces.

### Can email or phone be used as step variables?

Novu recommends not to use subscriber attributes as step variables. Instead, use the subscriber attributes directly in the step. For example, use `{{subscriber.email}}` instead of `{{email}}` as your step variable. Novu will select the email from subscriber attributes and inject the value in the content.

### How to use Provider templates in place of email content?

Currently, we support external Provider template support for [sendgrid](/channels-and-providers/email/sendgrid#using-sendgrid-template) and [mailersend](/channels-and-providers/email/mailersend#using-mailersend-template) only.

### Can I retrieve only Email content?

Novu does not have a separate API to retrieve email content. However, email content can be retrieved from the email step of the workflow. The email step contains the email content in the `content` field of [get worklfow api](/api-reference/workflows/get-workflow) response.

### How to send inline images in email?

Inline images can be sent using `<img>` tag in the email content. PNG, JPEG, GIF are supported. SVGs are not supported as inline images by most of email clients like gmail, outlook.

### How to add unsubscribe link in emails?

Add `{{unsubscribe}}` variable in email step content editor and send url value of this variable in payload. Create a simple html page to [fetch preferences](https://docs.novu.co/api-reference/subscribers/get-subscriber-preferences) and then use [update preference api](https://docs.novu.co/api-reference/subscribers/update-subscriber-preference) to update.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# In App
Source: https://v0.x-docs.novu.co/help/channels/in-app



### Creating two In-App Notification Centers in one account

To configure your In-App notifications, you must use the In-App integration from our integration store.

To display in-app notifications to users, any SDKs in our [client library](/notification-center/introduction) can be used. Every library requires `applicationIdentifier` and `subscriberId` to fetch notifications. Currently, only one `applicationIdentifier` is supported per environment per organization.

Feel free to reach out to us at [support@novu.co](mailto:support@novu.co) if you have speicific requirements of multiple `applicationIdentifier` per organization.

### Issues with a redirect URL

To redirect to specified redirect url on clicking the in-app notification, notification click event should be handled in client side code. Here is an example in [React](/notification-center/client/react/get-started#onnotificationclick).

### Changing the default colors of the Notification Center

Styling of your In-App Notification Center can be customized using the [styles](/notification-center/client/react/customization#customization-using-styles-prop) prop. If you want to customize only a single component, you can use [available](/notification-center/client/react/customization#popovernotificationcenter-customization) props.

### Additional Security for In-App Notifications

To add an extra layer of security, we recommend using our HMAC encryption feature to eliminate subscriber impersonation Checkout [HMAC](/notification-center/client/react/get-started#hmac-encryption) section for more details.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Push
Source: https://v0.x-docs.novu.co/help/channels/push



### Can I send a Desktop Push notification?

Yes, Desktop Push Notifications can be sent by using a Web Push Notification. It is supported with almost all [push channel](/channels-and-providers/push/overview) providers.

### Why am I getting the error “unexpected provider” with FCM?

The possible reasons for this error are:

* Invalid FCM credentials.
* Invalid or stale FCM token.

### Why am I getting the error “Sending message failed due to Requested entity was not found” with FCM?

* This error occurs when the FCM token is invalid or stale. You can fix this by updating the FCM device token.

### Can I store device tokens for particular FCM integration if I have multiple FCM providers active?

* Device tokens for particular FCM integration can be stored using the `integrationIdentifier` field of [update subscriber credentials api](/api-reference/subscribers/update-subscriber-credentials). `integrationIdentifier` is the unique identifier of the integration which is similar to `providerIdentifier`. It can be copied from the integration form.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# SMS
Source: https://v0.x-docs.novu.co/help/channels/sms



### Why am I getting the error “ subscriber does not have a configured channel”?

This error occurs when a Subscriber is missing `phone` attribute. To fix this error, you need to update the subscriber and set the `phone` attribute with a valid phone number.

### How to change the default sender name for SMS?

First, ensure a custom sendername (sender id or from) is allowed with your Provider. Some countries expect to verify the sender name before using it.

You can change the default sender name for SMS by using [overrides](/channels-and-providers/sms/overview#sending-sms-overrides) field while triggering the workflow.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Content Management
Source: https://v0.x-docs.novu.co/help/content-management



### What is a Layout and how can I use them?

Layout is similar to a style container for email templates. Layouts can be used for your organization’s branding and style. It can be used to define the structure of the email template such as the header, footer, and other common elements. It must have a `{{{body}}}` variable which will be replaced by the actual email template content.

### Can Layouts be used across all channels?

Layouts are specific to Emails.

### Can MJML templates be used in content editors?

Only HTML templates can be used in content editors. We support [handlebar helpers](/content-creation-design/handlebars-helpers) for common use cases like iteration, conditions etc. If you need any specific Handlebar Helpers, please reach out to us at [support@novu.co](mailto:support@novu.co).

### Can the content of one Step be used in another?

Currently each Step has content that is unique to it and can not be reused. If this is important to you, please send us a note at [support@novu.co](mailto:support@novu.co).

### Which Translation Language will be used if the Subscriber’s locale field does not match with translation language files?

If the Subscriber's locale field does not match with Translation locale files, or it is not available, then the defaul language of the translation group will be used. If a default is not set, the automatic fallback is English.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Frequently Asked Questions
Source: https://v0.x-docs.novu.co/help/faq



## Platform

### What is an event?

An event is every call to our [trigger API](https://docs.novu.co/api-reference/events/trigger-event/?utm_campaign=docs-faq) or digested with other notifications into any call can be converted through the Novu logic engine into many different notifications or digested with other ones into one notification. In case a trigger was used for many subscribers at once, it will be calculated per unique subscriber. In case many events are converted into one notification they will be calculated at a lower rate.

### What is a notification?

A notification is any message sent over any channel, after the Novu logic engine, Novu user preferences, and your configuration calculated and crafted the message. A notification can be sent to an email, In-App notification center, chat, push, and more.

### What is the difference between seen and read in the context of notifications?

An in-app notification (message) is marked as seen when you open the notification center and that notification(message) is visible
whereas it is marked as read either by clicking on that notification (message) or clicking the 'Mark as Read' option.

### I want to send millions of events, but only send thousands of notifications, can I?

Sure thing! This can easily be done using Novu’s digest + delay, features allowing for ingesting many events into well crafted must have messages over all channels.

### What are the differences between Novu Cloud and Open Source?

Novu [Open source](https://github.com/novuhq/novu) is a technology available under an MIT license, built and maintained by the Novu community, you can adapt it to your needs, contribute, or simply use docker files and run it. Novu Cloud is a managed service run, managed, and maintained by Novu Cloud version is scalable and robust by design, and uptime SLAs, and includes more business-facing features, that are not available under the Open Source version.

### Can I send more than 1 million events a month on Novu Cloud?

Yes, you absolutely can. Our managed cloud system was built to scale with your usage, so you don’t have to worry about it.

### I need some help configuring Novu, where can I find it?

No worries, we got your back. Many questions can be answered on our [documentation site](https://docs.novu.co/?utm_campaign=docs-faq). If for some reason something is missing, go ahead and use our [Discord](https://discord.gg/novu?ref=docs-faqs), we usually answer right away, and with the help of the community members and moderators, it’s very effective.

### What are the differences between Discord and Intercom support?

We have two main public support channels, Discord and Intercom. Discord is our community support channel supporting anything between self-hosted issues, bugs, code contributions, general discussions, feature requests, Novu-Cloud questions, and don’t forget memes :) On our Intercom support, we focus on Novu-Cloud questions, and ensure we can provide the best support based on our knowledge of Cloud usage.

### Where can I find the roadmap?

Glad you want to see what’s next, check out our roadmap [here](https://roadmap.novu.co/roadmap). Feel free to suggest other things and upvote features and requests.

### Does the Novu In-App notification center work with Angular, Vue, and React?

Yes, it does, The Novu In-App notification center is built using pure HTML components, and wrapped in your most beloved frameworks wrapper to provide a nice and consistent developer experience.

### Do you offer any enterprise plan?

Yes, we do. Enterprise plans are available for teams who require extended enterprise-grade features, and specific SLAs or have unique concerns about PII, security, insurance, or legal. Feel free to reach out to us over Intercom, or go to [contact us](https://novu.co/contact-us/?utm_campaign=docs-faq).

### Do you have offer enterprise support plan?

As part of our enterprise support, you’ll get our usual support channels as well as a Microsoft Teams/Slack/Discord channel. In case you want to add an enterprise support plan, with dedicated technical support, we are happy to offer that next to an active enterprise plan.

### I need more events or enterprise features, can you help?

We sure can. We are happy to work with enterprises and build Novu to support both their needs as well as the grand community ones. From new features, security, and privacy, or if you need to send dozens or hundreds of events a month, we are here to help. Feel free to reach out to us over Chat, or [contact us](https://novu.co/contact-us/?utm_campaign=docs-faq).

### Can I see some examples of how to use Novu?

Code examples can be found on our [Github Repo](https://github.com/novuhq/examples), and [our documentation](https://docs.novu.co/getting-started/your-first-notification?utm_campaign=docs-faq). We have examples for common use cases like sending notifications from a web server, mobile app, or integrating with other services.

### I am missing a channel provider, can I ask for one? Or add it myself?

You sure can, if you just want to ask for a new one, the easiest way is to go to our [Github issues](https://github.com/novuhq/novu/issues), and ask for a [new one](https://github.com/novuhq/novu/issues/new?assignees=\&labels=feature\&template=feature_request.yml\&title=%F0%9F%9A%80+Feature%3A+), just make sure if there is another request you upvote it instead of creating a new one. If you are willing to contribute a provider just go to [how to contribute one](https://docs.novu.co/community/add-a-new-provider?utm_campaign=docs-faq) on our docs, thank you!

### Do you have a status page?

Yes we do, check it out [here](https://novustatus.com/).

### I started using Novu Open Source, and I want to move to Novu Cloud, is there any migration tool?

We are now building an automatic tool to help with this migration process, for now, feel free to ask us over Discord, or at [engineering@novu.co](mailto:engineering@novu.co).

## Pricing

### Can I use Novu free of charge?

Yes, you can. If you send less than 30K events per month, then Novu Cloud is entirely free. Another option is to deploy the Open-Source version of Novu onto your own infrastructure, but that does not give you the unique SLA and global redundancy we have in the Cloud version of Novu.

### What is the pricing?

Pricing page is available [here](https://novu.co/pricing/?utm_campaign=docs-faq).

### If I am sending millions of events, but thousands of notifications, will this affect the price?

That’s a great way to do it, sending many events and only handful of notifications means you are able to convey a lot of value while keeping your subscribers happy. We are not only supporting it, it’s also affecting price. On high-volume events to notification, where digest is heavily used each event is calculated as 1/10 of the normal usage.


# Observability
Source: https://v0.x-docs.novu.co/help/observability

Analyzing your Triggered Events and Notification execution logs

### My Subscribers have preferences set, but the Activity Feed is showing Triggers as being sent.

The Activity Feed is a place each event (Workflow Trigger) is listed. If a Subscriber has a preference to not receive notifications through a certain channel, Novu’s system will adhere to that. However, this is still a valid Trigger as the fanout occurs before preferences are accommodated.

### What does "step filtered by subscriber preferences" mean in the logs?

It means that the Subscriber has set preferences configured and the step was filtered based on that preference. If the subscriber has disabled a step Channel then, the step will be filtered and notification will not be sent to the subscriber.

### How to export Activity Feed data?

Currently, we don't have any option to export activity feed data. But you can use our [API](/api-reference/notification/get-notifications) to fetch the data. If there is a specific system you’re looking to integrate with, please send us a note at [support@novu.co](mailto:support@novu.co).

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Orchestration
Source: https://v0.x-docs.novu.co/help/orchestration



## Digest

### New event triggers are merging an active Digest with an old duration..

When a Digest is created with a set duration and an event is triggered, the Digest stays active ( and will batch the events) until the configured duration is over.

If you change the duration before the initial time period has completed , the previous digest will still be active and the new duration is merged with the old duration Digest until the previous duration is complete.

To remove the previous Digest, use [event cancel api](/api-reference/events/cancel-triggered-event) to cancel all event triggers that are still pending and are merged in active Digests.

### Can I dynamically make the Digest inactive??

Yes, Digest supports conditions and can be applied to your Digest step. If the Triggered Event passes the set conditions, then it will be active or inactive based on the condition.

### Can a Subscriber control the Digest duration and time?

Not currently. The Digest duration  can be changed at the Workflow level only and is applied to all subscribers that Workflow is triggered to. If you have an identified use case for this, please let us know at [support@novu.co](mailto:support@novu.co).

## Delay

### What happens if the delay scheduled date and time is in the past?

If the delay scheduled date and time is in the past, the delay step will fail. Based on the step configuration, workflow will either continue to the next step or workflow will be failed

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Others
Source: https://v0.x-docs.novu.co/help/others



### Workkflows changes are not showing on the changes

If some changes are pending to promote for the same workflow, then Novu merges subsequent changes into the existing change item.

### Getting CORS error with the API

Novu APIs are developed to be used on the server side. If you are using the API from the browser, you will get a CORS error. You can use the API from the server side or checkout our [client-side libraries](/notification-center/introduction) to fetch in-app notifications.


# Help Center Overview
Source: https://v0.x-docs.novu.co/help/overview

Introduction to Novu help center

At our Help Center, we're dedicated to provide comprehensive support to ensure your experience with our products and services is seamless and enjoyable. Whether you're a new user looking for guidance or a seasoned customer seeking assistance, we're here to help. Help Center is organized as per our product architecture and is divided into the following sections:

<CardGroup>
  <Card title="Account Management" href="/help/account-management" icon="user">
    Manage your account and access your data.
  </Card>

  <Card title="User Management" href="/help/user-management" icon="users">
    Manage subscribers and topics
  </Card>

  <Card title="Channels" href="/help/channels" icon="bars">
    Explore all channels and how to use each one.
  </Card>

  <Card title="Orchestration" href="/help/orchestration" icon="screwdriver-wrench">
    Explore orchestration digest, delay, conditions and more.
  </Card>

  <Card title="Content Management" href="/help/content-management" icon="file-pen">
    Content management, layouts, templates, and more.
  </Card>

  <Card title="Observability" href="/help/observability" icon="magnifying-glass">
    Observability, metrics, analytics, and more.
  </Card>

  <Card title="Others" href="/help/Others" icon="crystal-ball">
    Others help topics.
  </Card>

  <Card title="FAQs" href="/help/faq" icon="comment">
    Read frequently asked questions
  </Card>
</CardGroup>

<Frame>
  <img />
</Frame>


# User Management
Source: https://v0.x-docs.novu.co/help/user-management



## Subscribers

### What is a Subscriber?

A subscriber is an entity to which notifications are sent. It is a Novu term similar to a user in your system. As in your system, a user is identified by a unique id, similarly in Novu, a subscriber is identified by a unique id called `subscriberId`. We recommend that the existing value you use in your system as a `userId` to be used as `subscriberId` in Novu. Read more about subscribers on [subscribers documentation page](/subscribers/subscribers).

### Is it necessary to use subscriberId as same as userId?

No, it is not necessary to use subscriberId as same as userId. You can use any unique id as subscriberId. We recommend using userId as subscriberId to avoid any confusion. Some of our customers use a pattern like `auth0|userId` as a value for `subscriberId`.

### Can notification be sent without adding a Subscriber?

No, a notification cannot be sent without adding a subscriber. A subscriber is an entity to which notifications are sent. You need to add a subscriber to Novu before triggering the workflow or inline of trigger. Read more about subscribers on [subscribers documentation page](/subscribers/subscribers).

### What is the right approach to add Subscribers?

Subscribers can be added either [ahead of trigger](/subscribers/subscribers#1-ahead-of-trigger) or [inline of trigger](/subscribers/subscribers#2-inline-of-trigger). One way to add a subscriber using inline of trigger is to create  a new subscriber in Novu as soon as they sign up or register in your system.

You can add your existing users as subscribers in Novu using [bulk create subscriber creation method](/subscribers/subscribers#bulk-subscriber-creation).

### Can Subscriber credentials be added while creating a new Subscriber?

Subscriber credentials for Push and Chat channel providers cannot be added while creating a new subscriber. Subscriber credentials for Push and Chat channel providers can be added using the [update subscriber credentials api](/api-reference/subscribers/update-subscriber-credentials) or corresponding sdk methods.

SMS and Email channels are a bit different because all providers can work with the same value, so `email` and `phone` [attributes](/subscribers/subscribers#subscriber-attributes) can be added while creating a new Subscriber.

### Can Subscriber preferences be updated while adding a new Subscriber?

Subscriber preference cannot be updated while adding a new subscriber. Novu sets all channels as true by default for new subscribers. You can modify preferences at any time. Read more about [subscriber preferences](/subscribers/preferences).

### Can two subscribers with different `subscriberId`s have the same email address?

Yes, it is possible for two subscribers to have the same email address in our system. This is because the `subscriberId` is the unique identifier that distinguishes one subscriber from another. Even if two subscribers share the same email address, they will have different `subscriberId`s, which allows our system to identify and manage them separately.

## Topics

### Can a Subscriber be added to multiple topics at once?

Currently, Novu supports adding a subscriber to only one topic at a time. You can add a subscriber to multiple topics by calling the [add subscriber to topic api](/api-reference/topics/subscribers-addition) multiple times with a particular topic key


# C#/.NET
Source: https://v0.x-docs.novu.co/sdks/dotnet

Connect a .NET application to Novu

Novu's .NET SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your C#/.NET application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-dotnet)

## Installation

```dotnet theme={null}
dotnet add package Novu
```

<Tip>
   If you're ready to start integrating in your .NET app, jump straight to
  our [.NET quickstart.](/quickstarts/.NET)
</Tip>

## Usage

```dotnet theme={null}
using Novu.DTO;
using Novu.Models;
using Novu;
...

var novuConfiguration = new NovuClientConfiguration
{
    // Defaults to https://api.novu.co/v1
    Url = "https://novu-api.my-domain.com/v1",
    ApiKey = "12345",
};

var novu = new NovuClient(novuConfiguration);

// OnboardEventPayload.cs
public class OnboardEventPayload
{
  [JsonProperty("username")]
  public string Username { get; set; }

  [JsonProperty("welcomeMessage")]
  public string WelcomeMessage { get; set; }
}

// MyFile.cs
var onboardingMessage = new OnboardEventPayload
{
  Username = "jdoe",
  WelcomeMessage = "Welcome to novu-dotnet"
};

var payload = new EventTriggerDataDto()
{
  EventName = "onboarding",
  To = { SubscriberId = "subscriberId" },
  Payload = onboardingMessage
};

var trigger = await novu.Event.Trigger(payload);

if (trigger.TriggerResponsePayloadDto.Acknowledged)
{
  Console.WriteLine("Trigger has been created.");
}
```


# Go SDK
Source: https://v0.x-docs.novu.co/sdks/go

Connect a Go application to Novu

Novu's Go SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Go application.

[Explore the source code on GitHub](https://github.com/novuhq/go-novu)

## Installation

```go theme={null}
go get github.com/novuhq/go-novu
```

<Tip> If you're ready to start integrating in your Go app, jump straight to our [Go quickstart.](/quickstarts/go)</Tip>

## Usage

```go theme={null}
package main

import (
	"context"
	"fmt"
	novu "github.com/novuhq/go-novu/lib"
	"log"
)

func main() {
	subscriberID := "<REPLACE_WITH_YOUR_SUBSCRIBER>"
	apiKey := "<REPLACE_WITH_YOUR_API_KEY>"
	eventId := "<REPLACE_WITH_YOUR_EVENT_ID>"

	ctx := context.Background()
	to := map[string]interface{}{
		"lastName":     "Doe",
		"firstName":    "John",
		"subscriberId": subscriberID,
		"email":        "john@doemail.com",
	}

	payload := map[string]interface{}{
		"name": "Hello World",
		"organization": map[string]interface{}{
			"logo": "https://happycorp.com/logo.png",
		},
	}

	data := novu.ITriggerPayloadOptions{To: to, Payload: payload}
	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

	resp, err := novuClient.EventApi.Trigger(ctx, eventId, data)
	if err != nil {
		log.Fatal("novu error", err.Error())
		return
	}

	fmt.Println(resp)

	// get integrations
	integrations, err := novuClient.IntegrationsApi.GetAll(ctx)
	if err != nil {
		log.Fatal("Get all integrations error: ", err.Error())
	}
	fmt.Println(integrations)
}
```


# Java SDK
Source: https://v0.x-docs.novu.co/sdks/java

Connect a Java application to Novu

Novu's Java SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Java application.

[Explore the source code on GitHub.](https://github.com/novuhq/novu-java)

## Installation

Maven users:

```java theme={null}
<!--add dependency-->
<dependency>
    <groupId>co.novu</groupId>
    <artifactId>novu-java</artifactId>
    <version>{use-latest-version}</version>
</dependency>
```

The latest version can be found [on GitHub.](https://github.com/novuhq/novu-java#installation)

Gradle users:

```groovy theme={null}
implementation 'co.novu:novu-java:{latest-version}'
```

Sync your project, and you should have the artifacts downloaded.

<Tip> If you're ready to start integrating in your Java app, jump straight to our [Java quickstart.](/quickstarts/java)</Tip>

## Usage

```java theme={null}
import co.novu.sdk.Novu;

public class Main {
    public static void main(String[] args) {
        String apiKey = "INSERT_API_KEY_HERE";
        // Using the API Key only
        Novu novu = new Novu(apiKey);

        // Using the Config Param
        NovuConfig novuConfig = new NovuConfig(apiKey);
        Novu novu = new Novu(novuConfig);

        // Sample usage
        novu.triggerEvent(event);
    }
}

// Sign up on https://web.novu.co and grab your API key from https://web.novu.co/settings
```


# Kotlin SDK
Source: https://v0.x-docs.novu.co/sdks/kotlin

Connect a Kotlin application to Novu

Novu's Kotlin SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Kotlin application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-kotlin)

## Installation

Maven users:

```xml theme={null}
<dependency>
  <groupId>co.novu</groupId>
  <artifactId>novu-kotlin</artifactId>
  <version>{use-latest-version}</version>
</dependency>
```

The latest version can be found [on GitHub.](https://github.com/novuhq/novu-kotlin#installation)

Gradle users:

```groovy theme={null}
implementation 'co.novu:novu-kotlin:{use-latest-version}' //Groovy

implementation ("co.novu:novu-kotlin:{use-latest-version}") //Kotlin
```

Sync your project, and you should have the artifacts downloaded.

<Tip> If you're ready to start integrating in your Kotlin app, jump straight to our [Kotlin quickstart.](/quickstarts/kotlin)</Tip>

## Usage

```kotlin theme={null}

// without changing the backend URL
import co.novu.Novu
import co.novu.extentions.environments

fun main() {
    val novu = Novu(apiKey = "NOVU_API_KEY")
    val environment = novu.environments()
    println(environment)
}

```


# Laravel
Source: https://v0.x-docs.novu.co/sdks/laravel

Connect a Laravel application to Novu

Novu's Laravel SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Laravel application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-laravel)

## Installation

```php theme={null}
composer require novu/novu-laravel
```

<Tip> If you're ready to start integrating in your Laravel app, jump straight to our [Laravel quickstart.]()</Tip>

## Usage

```php theme={null}
use Novu\Laravel\Facades\Novu;

$response = Novu::triggerEvent([
    'name' => '<WORKFLOW_TRIGGER_IDENTIFIER_FROM_DASHBOARD>',
    'payload' => ['customVariables' => 'Hello'],
    'to' => [
        'subscriberId' => '<SUBSCRIBER_ID_FROM_DASHBOARD>',
        'phone' => '07983887777'
    ]
])->toArray();

// or you can use the novu() helper function like so:
novu()->triggerEvent([
    'name' => '<WORKFLOW_TRIGGER_IDENTIFIER_FROM_DASHBOARD>',
    'payload' => ['customVariables' => 'Hello'],
    'to' => [
        'subscriberId' => '<SUBSCRIBER_ID_FROM_DASHBOARD>',
        'phone' => '07983887777'
    ]
])->toArray();
```


# Python SDK
Source: https://v0.x-docs.novu.co/sdks/python

Connect a Python application to Novu

Novu's Python SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Python application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-python)

## Installation

```python theme={null}
# Via pip
pip install novu

# Via poetry
poetry add novu
```

<Tip> If you're ready to start integrating in your Python app, jump straight to our [Python quickstart.](/quickstarts/python)</Tip>

## Usage

```python theme={null}
from novu.api import EventApi

url = "https://api.novu.co"
api_key = "<NOVU_API_KEY>"

# You can sign up on https://web.novu.co to get your API key from https://web.novu.co/settings

novu = EventApi(url, api_key).trigger(
    name="digest-workflow-example",  # This is the Workflow ID. It can be found on the workflow page.
    recipients="<SUBSCRIBER_IDENTIFIER>", # The subscriber ID can be gotten from the dashboard.
    payload={},  # Your custom Novu payload goes here
)
```


# Ruby SDK
Source: https://v0.x-docs.novu.co/sdks/ruby

Connect a Ruby application to Novu.

Novu's Ruby SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Ruby application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-ruby)

## Installation

```javascript theme={null}
gem install novu
```

<Tip> If you're ready to start integrating in your Ruby app, jump straight to our [Ruby quickstart.](/quickstarts/ruby)</Tip>

## Usage

```ruby theme={null}
require 'novu'

client = Novu::Client.new(access_token: 'YOUR_NOVU_API_TOKEN')

payload = {
    'name' => 'Trigger1',
    'payload' => { # optional
        'first-name' => 'Adam' # optional
    },
    'to' => {
        'subscriberId' => '7789'
    },
    'transactionId' => '89kjfke9893' #optional
}

client.trigger_event(payload)
```


# Activity Feed
Source: https://v0.x-docs.novu.co/activity-feed/introduction

Monitor all your activity from one place

## Introduction

Novu provides a notification activity feed that monitors every outgoing message associated with its relevant metadata. This can be used to monitor activity and discover potential issues with a specific provider or channel type.

<Frame>
  <img />
</Frame>

## Viewing a specific subscriber's activity

To use a subscriber's activity feed you can filter the feed by using the subscriberId or email. This will show only the relevant data for this particular subscriber.

To do this, just enter the `subscriberId` or the 'email' of the subscriber you want to get info of and then click the 'search' button on the right-hand side as shown in the image below:

<Frame>
  <img />
</Frame>

## Filter by workflow or channel

The activity feed allows you to filter messages based on the associated workflow or channel. This is helpful when you want to assess or debug a particular workflow and its behaviour.

Filtering by workflow or channel is quite simple. Just go to the Workflow dropdown (if you want to filter by workflow) or the channel tab (if you want to filter by channel) and select the corresponding workflow or channel and click the 'search' button on the right-hand side as shown in the image below:

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Troubleshooting with the activity feed

The activity feed also shows if a transaction is failing. You can see why a transaction is failing and rectify it. For example, take a look at the following image:

<Frame>
  <img />
</Frame>

You can see that an SMS notification has failed to get delivered. Clicking on it opens the execution details and the reason why that transaction failed

<Frame>
  <img />
</Frame>

This can help troubleshoot the problem and comes in handy at the time of distress.

## Digest info in the activity feed

If you’re using our digest notifications functionality, you’ll be able to see all the digest-related information in the activity feed.

<Frame>
  <img />
</Frame>

Some of the information related to digest present in the activity feed is:

* Digest step delay
* Digesting start time
* Digest triggered events details
* More digest execution details

<Frame>
  <img />
</Frame>

From here, you can see the details of ‘digest triggered events’ to see exactly which events were digested and the content of the notification you sent, as shown below:

<Frame>
  <img />
</Frame>

## Trigger Event Lifecycle

### **Trigger request**

The request contains details such as the identifier for the template, the list of subscribers who will receive the notification, the payload of the notification, and any overrides that need to be applied.

### Trigger endpoint

After the request is sent to the `/event/trigger` endpoint, the initial step involves mapping and validating the subscribers for that event. Following that, we validate the template and steps based on the active status or draft template flag.

Once the validation process is complete, the attachments are uploaded to the storage service.

Next, the trigger event with mapped subscribers and attachment links is appended to the **trigger event queue**. By queuing the events, we can achieve faster response times.

### **Trigger event processing**

When the event is picked up by the **trigger queue worker** we process it. For every subscriber listed in the trigger event, we create a notification entity and the corresponding jobs based on the notification template steps. The notification contains data related to the organization, template, subscriber, and event payload. It is updated with a channels field that is generated from the steps.

### **Jobs**

Every job is created according to the steps outlined in the template. If the template contains a digest step, the **filtering logic** is applied to produce the appropriate jobs array depending on the type of digesting: **regular** or **backoff**.


# Trigger Event Lifecycle
Source: https://v0.x-docs.novu.co/activity-feed/trigger-event-lifecycle

Managing Trigger Events from Request to Processing

## Trigger Request

A trigger request is the initial step in handling a trigger event. It contains crucial details such as the template identifier, a list of subscribers who will receive the notification, the payload of the notification, and any overrides that need to be applied.

## Trigger Endpoint

Upon sending the request to the `/event/trigger` endpoint, a series of essential steps are initiated:

1. **Subscriber Mapping and Validation:** The first step involves mapping and validating the subscribers for the specified event. This ensures that notifications are sent to the correct recipients.

2. **Template Validation:** Following subscriber validation, the template associated with the event is validated. This validation process considers factors such as the active status or draft template flag to determine if it meets the necessary criteria for processing.

3. **Attachment Upload:** Once the validation process is successfully completed, any attachments associated with the event are uploaded to the designated storage service.

4. **Event Queuing:** The trigger event, now enriched with mapped subscribers and attachment links, is appended to the **trigger event queue**. This queuing mechanism optimizes response times, ensuring efficient event processing.

## Trigger Event Processing

When an event is picked up by the **trigger queue worker**, the processing phase begins. Here's what happens:

* **Notification Entity Creation:** For each subscriber listed in the trigger event, a corresponding notification entity is created. This entity contains essential data related to the organization, template, subscriber, and event payload.

* **Job Creation:** Based on the notification template's defined steps, jobs are generated. These jobs are responsible for carrying out specific tasks related to the event notification. Additionally, the notification entity is updated with a "channels" field generated from these steps, indicating the communication channels through which notifications will be sent.

## Jobs

Jobs play a pivotal role in the trigger event lifecycle. They are created based on the steps outlined in the notification template. Depending on the presence of a digest step, the following logic is applied:

* **Digest Step:** If the template includes a digest step, filtering logic is applied to produce an appropriate array of jobs. This logic differentiates between two types of digesting: **regular** and **backoff**, each serving distinct purposes in event processing.

## Job Statuses

| Status        | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **PENDING**   | This status is assigned to a job before it is added to the worker queue. It indicates that the job is waiting to be processed.                                                                                                                                                                                                                                                                                                                                                                                                                       |
| **QUEUED**    | After the initial validation and just before adding a job to the worker queue, it is set to `QUEUED`. This status signifies that the job is ready for processing but is awaiting its turn in the queue.                                                                                                                                                                                                                                                                                                                                              |
| **RUNNING**   | When a job is picked up by a worker from the queue, its status is changed to `RUNNING`. This indicates that the job is currently being processed by a worker.                                                                                                                                                                                                                                                                                                                                                                                        |
| **COMPLETED** | Once a job has been successfully executed and processed, its status is changed to `COMPLETED`. This signifies that the job has been successfully completed.                                                                                                                                                                                                                                                                                                                                                                                          |
| **FAILED**    | If a job encounters an issue during processing or execution, its status is changed to `FAILED`. This indicates that the job has not been successfully completed, and there may have been errors or problems during processing.                                                                                                                                                                                                                                                                                                                       |
| **DELAYED**   | The `DELAYED` status is applied to specific types of jobs, such as `digest` or `delay` jobs, to indicate that they are delayed and not immediately processed. For `digest` jobs, it means that the digesting process is running or scheduled for a later time. For `delay` jobs, it signifies that the job is set to be executed at a specified delay time.                                                                                                                                                                                          |
| **CANCELED**  | When a job is canceled for any reason, its status is set to `CANCELED`. This indicates that the job will not be processed further and is effectively removed from the processing queue.                                                                                                                                                                                                                                                                                                                                                              |
| **MERGED**    | The `MERGED` status is assigned to events that are part of a `digest`. It indicates that an event will be merged into the digesting event. In a digesting process, there is typically a primary or initial event that serves as the digesting event, and subsequent events are merged into it. Instead of having a separate `COMPLETED` status for these merged events, they are marked as `MERGED` to indicate their specific role in the digesting process.                                                                                        |
| **SKIPPED**   | The `SKIPPED` status is used in the context of backoff versions of digesting. In this scenario, the first event's digesting is skipped, and the second event takes on the digesting role. The `SKIPPED` status is applied to the first event's digesting, indicating that it was intentionally skipped in the digesting process. Subsequent events may be merged into the second event's digesting process, as explained with the `MERGED` status. The `SKIPPED` status helps differentiate the skipped event from others in the digesting sequence. |

**Example:**

<Frame>
  <img />
</Frame>

<Steps>
  <Step title="Step created">
    `PENDING`
  </Step>

  <Step title="Step queued">
    `QUEUED`
  </Step>

  <Step title="Start sending message">
    `RUNNING`
  </Step>

  <Step title="Message created">
    `RUNNING`
  </Step>

  <Step title="Message sent">
    `COMPLETED`
  </Step>
</Steps>


# Apply change
Source: https://v0.x-docs.novu.co/api-reference/changes/apply-change

post /v1/changes/{changeId}/apply

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.changes.applyOne("changeId");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->applyChange($changeId, []);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.apply_change(`<change_id≥`)
  ```

  ```python Python theme={null}
  from novu.api import ChangeApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = ChangeApi(url, api_key).apply(
      change_id = "<A change ID to apply>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.applyChange('changeId');
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "_creatorId": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_entityId": "string",
        "enabled": true,
        "type": "Feed",
        "change": {},
        "createdAt": "string",
        "_parentId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Apply changes
Source: https://v0.x-docs.novu.co/api-reference/changes/apply-changes

post /v1/changes/bulk/apply

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.changes.applyMany(["changeId1", "changeId2"]);
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->applyBulkChanges([
      'changeIds' = [
          '<insert-all-the-change-ids>'
      ]
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.apply_change({
      'changeIds' => ['<insert-all-the-change-ids>']
  })
  ```

  ```python Python theme={null}
  from novu.api import ChangeApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = ChangeApi(url, api_key).bulk_apply(
      change_ids = "<The list of IDs to apply>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.applyBulkChanges("<list-of-change-ids>");
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "_creatorId": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_entityId": "string",
        "enabled": true,
        "type": "Feed",
        "change": {},
        "createdAt": "string",
        "_parentId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Get changes
Source: https://v0.x-docs.novu.co/api-reference/changes/get-changes

get /v1/changes

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.changes.get();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getChanges();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.changes({
      'page' => 1, # optional
      'limit' => 10, # optional
      'promoted' => 'hello'
  })
  ```

  ```python Python theme={null}
  from novu.api import ChangeApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = ChangeApi(url, api_key).list(
      page = "<Page to retrieve>",
      limit = "<Size of page>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.changes(query = {});
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      totalCount: 0,
      data: [data],
      pageSize: 0,
      page: 0
  }
  ```
</ResponseExample>


# Get changes count
Source: https://v0.x-docs.novu.co/api-reference/changes/get-changes-count

get /v1/changes/count

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.changes.getCount();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getChangesCount()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.count_changes()
  ```

  ```python Python theme={null}
  from novu.api import ChangeApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = ChangeApi(url, api_key).count(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.countChanges();
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      data: 0
  }
  ```
</ResponseExample>


# Get api keys
Source: https://v0.x-docs.novu.co/api-reference/environments/get-api-keys

get /v1/environments/api-keys

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.environmets.getApiKeys();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getEnvironmentsAPIKeys()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.api_keys()
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.apiKeys();
      }
  }
  ```

  ```python Python theme={null}
  from novu.api import EnvironmentApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  apiKeys = EnvironmentApi(url, api_key).api_keys()
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.apiKeys

  fun main() {
      val novu = Novu(apiKey = "API_KEY")
      val apiKeys = novu.apiKeys()
      println(apiKeys)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
       --url https://api.novu.co/v1/environments/api-keys \
       --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "key": "string",
        "_userId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Get current environment
Source: https://v0.x-docs.novu.co/api-reference/environments/get-current-environment

get /v1/environments/me

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.environments.getCurrent();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->getCurrentEnvironment()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.current_environment()
  ```

  ```python Python theme={null}
  from novu.api import EnvironmentApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = EnvironmentApi(url, api_key).current(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.currentEnvironment();
      }
  }
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.currentEnvironment

  fun main() {
      val novu = Novu(apiKey = "API_KEY")
      val currentEnvironment = novu.currentEnvironment()
      println(currentEnvironment)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
       --url https://api.novu.co/v1/environments/me \
       --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "_organizationId": "string",
      "identifier": "string",
      "apiKeys": [
        {
          "key": "string",
          "_userId": "string"
        }
      ],
      "_parentId": "string"
    }
  }
  ```
</ResponseExample>


# List all environments
Source: https://v0.x-docs.novu.co/api-reference/environments/get-environments

get /v1/environments
This API returns a list of environments for the current organization. 
    Each environment contains its configuration, API keys (if user has access), and metadata.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.environments.getAll();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getEnvironments()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.environments()
  ```

  ```python Python theme={null}
  from novu.api import EnvironmentApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = EnvironmentApi(url, api_key).list(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.environments();
      }
  }
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.environments

  fun main() {
      val novu = Novu(apiKey = "API_KEY")
      val environment = novu.environments()
      println(environment)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
       --url https://api.novu.co/v1/environments \
       --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "name": "string",
        "_organizationId": "string",
        "identifier": "string",
        "apiKeys": [
          {
            "key": "string",
            "_userId": "string"
          }
        ],
        "_parentId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Regenerate api keys
Source: https://v0.x-docs.novu.co/api-reference/environments/regenerate-api-keys

post /v1/environments/api-keys/regenerate

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.environmets.regenerateApiKeys();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $key = $novu->regenerateEnvironmentsAPIKeys()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.regenerate_api_keys()
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.regenerateApiKeys();
      }
  }
  ```

  ```python Python theme={null}
  from novu.api import EnvironmentApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  regenerateApiKey = EnvironmentApi(url, api_key).regenerate_api_key()
  ```

  ```bash cURL theme={null}
  curl --request POST \
       --url https://api.novu.co/v1/environments/api-keys/regenerate \
       --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "key": "string",
        "_userId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Get execution details
Source: https://v0.x-docs.novu.co/api-reference/execution-details/get-execution-details

get /v1/execution-details

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request GET \
      --url https://api.novu.co/v1/execution-details \
      --header 'Authorization: <authorization>' 
  ```

  ```javascript Node.js theme={null}
  import fetch from 'node-fetch';

  const response = await fetch('https://api.novu.co/v1/execution-details', {
    method: 'GET',
    
  });
  const data = await response.json();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  // Get execution details
  $novu->getExecutionDetails([
      'notificationId' => '<insert-notification-id>',
      'subscriberId'   => '<insert-subscriber-id>'
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.execution_details({
      'notificationId' => '8fxxx-xxx-ef9xxxxce66',
      'subscriberId' => '7789'
  })
  ```

  ```python Python theme={null}
  from novu.api import ExecutionDetailApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = ExecutionDetailApi(url, api_key).list(
      notification_id = "<The notification ID in Novu>",
      subscriber_id = "<The subscriber ID in Novu>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.executionDetails(query = {});
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "_organizationId": "string",
        "_jobId": "string",
        "_environmentId": "string",
        "_notificationId": "string",
        "_notificationTemplateId": "string",
        "_subscriberId": "string",
        "_messageId": "string",
        "providerId": "string",
        "transactionId": "string",
        "channel": "in_app",
        "detail": "string",
        "source": "Credentials",
        "status": "Success",
        "isTest": true,
        "isRetry": true,
        "createdAt": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Create feed
Source: https://v0.x-docs.novu.co/api-reference/feeds/create-feed

post /v1/feeds

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request POST \
  --url https://api.novu.co/v1/feeds \
  --header 'Authorization: ApiKey <NOVU_API_KEY>' \
  --header 'Content-Type: application/json' \
  --data '{"name": "<FEED_NAME>"}'
  ```

  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.feeds.create("<Feed_Name>");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->createFeed([
      'name' => '<insert-name-for-feed>'
  ]);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.create_feed({
      'name' => 'New feed'
  })
  ```

  ```python Python theme={null}
  from novu.api import FeedApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = FeedApi(url, api_key).create(
      name = "<Feed_Name>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.createFeed(body);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "identifier": "string",
      "_environmentId": "string",
      "_organizationId": "string"
    }
  }
  ```
</ResponseExample>


# Delete feed
Source: https://v0.x-docs.novu.co/api-reference/feeds/delete-feed

delete /v1/feeds/{feedId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request DELETE \
  --url https://api.novu.co/v1/feeds/{FEED_IDENTIFIER} \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.feeds.delete("<Feed_Id>");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->deleteFeed();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.delete_feed("<Feed_Id>")
  ```

  ```python Python theme={null}
  from novu.api import FeedApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = FeedApi(url, api_key).delete(
      Feed_Id = "<ID of the feed to be deleted>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.deleteFeed(Feed_Id);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "name": "string",
        "identifier": "string",
        "_environmentId": "string",
        "_organizationId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Get feeds
Source: https://v0.x-docs.novu.co/api-reference/feeds/get-feeds

get /v1/feeds

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/feeds \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.feeds.get();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->getFeeds()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.feeds()
  ```

  ```python Python theme={null}
  from novu.api import FeedApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = FeedApi(url, api_key).list(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.feeds();
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "name": "string",
        "identifier": "string",
        "_environmentId": "string",
        "_organizationId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Get v1blueprints
Source: https://v0.x-docs.novu.co/api-reference/get-v1blueprints

get /v1/blueprints/{templateId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get v1blueprintsgroup by category
Source: https://v0.x-docs.novu.co/api-reference/get-v1blueprintsgroup-by-category

get /v1/blueprints/group-by-category

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Validate the mx record setup for the inbound parse functionality
Source: https://v0.x-docs.novu.co/api-reference/inbound-parse/validate-the-mx-record-setup-for-the-inbound-parse-functionality

get /v1/inbound-parse/mx/status

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import fetch from 'node-fetch';

  const response = await fetch('https://api.novu.co/v1/inbound-parse/mx/status', {
    method: 'GET',
    
  });
  const data = await response.json();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);


  // Validate MX Record for Inbound Parse
  $novu->validateMXRecordForInboundParse()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.validate_mx_record_setup_for_inbound_parse()
  ```

  ```python Python theme={null}
  from novu.api import InboundParseApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = InboundParseApi(url, api_key).validate_mx_record_setup(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.validateMxRecordSetupForInboundParse();
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
      "mxRecordConfigured": true
    }
  }
  ```
</ResponseExample>


# Create an integration
Source: https://v0.x-docs.novu.co/api-reference/integrations/create-integration

post /v1/integrations
Create an integration for the current environment the user is based on the API key provided. 
    Each provider supports different credentials, check the provider documentation for more details. Only integration metadata is returned, credentials field is returned as an empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --location 'https://api.novu.co/v1/integrations' \
  --header 'Content-Type: application/json' \
  --header 'Accept: application/json' \
  --header 'Authorization: ApiKey <NOVU_API_KEY>' \
  --data '{
      "name": "SES",
      "identifier": "ses-NkIQ5Koy3-123",
      "credentials": {
          "apiKey": "ACCESS_KEY_ID",
          "secretKey": "SECRET_ACCESS_KEY",
          "region": "us-east-2",
          "from": "FROM_EMAIL_ADDRESS",
          "senderName": "SENDER_NAME",
          // ... other credentials as per provider
      },
      "conditions": [],
      "active": true,
      "check": false,
      "providerId": "ses",
      "channel": "email"
  }'
  ```

  ```javascript Node.js theme={null}
  import { Novu, ChannelTypeEnum, ProvidersIdEnum } from '@novu/node';  
  const novu = new Novu('<NOVU_API_KEY>');

  const createPaylod = {
    name: "SendGrid",
    identifier: "sendgrid-identifier",
    credentials: {
      apiKey: "SUPER_SECRET_API_KEY",
      from: "sales@novu.co",
      senderName: "Novu Sales Team",
      channel: ChannelTypeEnum.EMAIL,
      // ... other credentials as per provider
    },
    active: true,
    check: false
  }

  await novu.integrations.create(ProvidersIdEnum.SendGrid, createPayload);
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  // Create integration
  $novu->createIntegration([
      'providerId' => '<insert->provider->id>',
      'channel' => '<insert->channel>',
      'credentials' => [
          // insert all the fields
      ],
      'active' => true,
      'check' => true
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  body = {
      'providerId' => '<insert-provider-id>',
      'channel' => '<insert-channel>',
      'credentials' => {
          # insert all the fields
      },
      'active' => true,
      'check' => true
  }
  client.create_integration(body)
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).create(
      integration="", # Integration instance that you want to create.
      check="", # If you want the Novu server to check his connection using given integration configuration. Defaults to True.

  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.createIntegration(body)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "_environmentId": "string",
      "_organizationId": "string",
      "name": "string",
      "identifier": "string",
      "providerId": "string",
      "channel": "in_app",
      "credentials": {
        "apiKey": "string",
        "user": "string",
        "secretKey": "string",
        "domain": "string",
        "password": "string",
        "host": "string",
        "port": "string",
        "secure": true,
        "region": "string",
        "accountSid": "string",
        "messageProfileId": "string",
        "token": "string",
        "from": "string",
        "senderName": "string",
        "projectName": "string",
        "applicationId": "string",
        "clientId": "string",
        "requireTls": true,
        "ignoreTls": true,
        "tlsOptions": {},
        "baseUrl": "string",
        "webhookUrl": "string",
        "redirectUrl": "string",
        "hmac": true,
        "serviceAccount": "string",
        "ipPoolName": "string"
      },
      "active": true,
      "deleted": true,
      "deletedAt": "string",
      "deletedBy": "string",
      "primary": true
    }
  }
  ```
</ResponseExample>


# Delete an integration
Source: https://v0.x-docs.novu.co/api-reference/integrations/delete-integration

delete /v1/integrations/{integrationId}
Delete an integration by its unique key identifier **integrationId**. 
    This action is irreversible. Only integration metadata is returned, credentials field is returned as empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';  

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.integrations.delete("integrationId");
  ```

  ```php PHP theme={null}
  // Get integrations
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');
  $novu->deleteIntegration($integrationId);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.delete_integration('<insert-provider-id>')
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).delete(
      integration_id="<The integration ID>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.deleteIntegration(integrationId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "name": "string",
        "identifier": "string",
        "providerId": "string",
        "channel": "in_app",
        "credentials": {
          "apiKey": "string",
          "user": "string",
          "secretKey": "string",
          "domain": "string",
          "password": "string",
          "host": "string",
          "port": "string",
          "secure": true,
          "region": "string",
          "accountSid": "string",
          "messageProfileId": "string",
          "token": "string",
          "from": "string",
          "senderName": "string",
          "projectName": "string",
          "applicationId": "string",
          "clientId": "string",
          "requireTls": true,
          "ignoreTls": true,
          "tlsOptions": {},
          "baseUrl": "string",
          "webhookUrl": "string",
          "redirectUrl": "string",
          "hmac": true,
          "serviceAccount": "string",
          "ipPoolName": "string"
        },
        "active": true,
        "deleted": true,
        "deletedAt": "string",
        "deletedBy": "string",
        "primary": true
      }
    ]
  }
  ```
</ResponseExample>


# List active integrations
Source: https://v0.x-docs.novu.co/api-reference/integrations/get-active-integrations

get /v1/integrations/active
List all the active integrations created in the organization. Only integration metadata is returned, credentials field is returned as an empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node'; 

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.integrations.getActive();
  ```

  ```php PHP theme={null}
  // Get integrations
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getActiveIntegrations()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.active_integrations()
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).list(
      only_active=true # This allows one to retrieve only active integrations. Defaults to False.
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.activeIntegrations()
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```
  {
      _id: "_id",
      _environmentId: "_environmentId",
      _organizationId: "_organizationId",
      name: "name",
      identifier: "identifier",
      providerId: "providerId",
      channel: "channel",
      credentials: credentials,
      active: true,
      deleted: true,
      deletedAt: "deletedAt",
      deletedBy: "deletedBy",
      primary: true
  }
  ```
</ResponseExample>


# List all integrations
Source: https://v0.x-docs.novu.co/api-reference/integrations/get-integrations

get /v1/integrations
List all the channels integrations created in the organization. Only integration metadata is returned, credentials field is returned as an empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';  

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.integrations.getAll();
  ```

  ```php PHP theme={null}
  // Get integrations
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getIntegrations()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.integrations()
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
      // get integrations
  	integrations, err := novuClient.IntegrationsApi.GetAll(ctx)
  	if err != nil {
  		log.Fatal("Get all integrations error: ", err.Error())
  	}
  	fmt.Println(integrations)
  }
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).list(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.integrations()
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      _id: "_id",
      _environmentId: "_environmentId",
      _organizationId: "_organizationId",
      name: "name",
      identifier: "identifier",
      providerId: "providerId",
      channel: "channel",
      credentials: credentials,
      active: true,
      deleted: true,
      deletedAt: "deletedAt",
      deletedBy: "deletedBy",
      primary: true
  }
  ```
</ResponseExample>


# Get webhook support status for provider
Source: https://v0.x-docs.novu.co/api-reference/integrations/get-webhook-support-status-for-provider

get /v1/integrations/webhook/provider/{providerId}/status

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu, ProvidersIdEnum } from '@novu/node';  

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.integrations.getWebhookProviderStatus(ProvidersIdEnum.SendGrid);
  ```

  ```php PHP theme={null}
  // Get integrations
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getWebhookSupportStatusForProvider($providerId)->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.webhook_provider_status('<insert-provider-id>')
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).status(
      provider_id="<The_Provider_ID>", # Get webhook support status for a given provider using its providerID.
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.webhookProviderStatus(providerId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      200: "The status of the webhook for the provider requested"
  }
  ```
</ResponseExample>


# Update integration as primary
Source: https://v0.x-docs.novu.co/api-reference/integrations/set-integration-as-primary

post /v1/integrations/{integrationId}/set-primary
Update an integration as **primary** by its unique key identifier **integrationId**. 
    This API will set the integration as primary for that channel in the current environment. 
    Primary integration is used to deliver notification for sms and email channels in the workflow. 
    Only integration metadata is returned, credentials field is returned as an empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';  

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.integrations.setIntegrationAsPrimary("integrationId")
  ```

  ```php PHP theme={null}
  <?php

  $url = 'https://api.novu.co/v1/integrations/:integrationId/set-primary';
  $data = array(
    [options]
  );
  $options = array(
    "http" => array(
    "header"  => "Content-type: application/json",
    "header"  => "Authorization: ApiKey REPLACE_WITH_API_KEY",
    "method"  => "POST",
    "content" => json_encode($data)
    )
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);

  if ($result === FALSE) { /* Handle error */ }

  echo $result;
      
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'uri'

  uri = URI.parse('https://api.novu.co/v1/integrations/:integrationId/set-primary')
  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri)

  request.body = '{
    [options]
  }'
  request.content_type = 'application/json'
  request.add_field('Authorization', 'ApiKey REPLACE_WITH_API_KEY')


  response = http.request(request)

  puts response.body
      
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/integrations/:integrationId/set-primary"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
  ```

  ```python Python theme={null}
  import requests

  response = requests.post('https://api.novu.co/v1/integrations/:integrationId/set-primary')

  print(response.json())
      
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "_id": "string",
    "_environmentId": "string",
    "_organizationId": "string",
    "name": "string",
    "identifier": "string",
    "providerId": "string",
    "channel": "in_app",
    "credentials": {
      "apiKey": "string",
      "user": "string",
      "secretKey": "string",
      "domain": "string",
      "password": "string",
      "host": "string",
      "port": "string",
      "secure": true,
      "region": "string",
      "accountSid": "string",
      "messageProfileId": "string",
      "token": "string",
      "from": "string",
      "senderName": "string",
      "projectName": "string",
      "applicationId": "string",
      "clientId": "string",
      "requireTls": true,
      "ignoreTls": true,
      "tlsOptions": {},
      "baseUrl": "string",
      "webhookUrl": "string",
      "redirectUrl": "string",
      "hmac": true,
      "serviceAccount": "string",
      "ipPoolName": "string"
    },
    "active": true,
    "deleted": true,
    "deletedAt": "string",
    "deletedBy": "string",
    "primary": true
  }
  ```
</ResponseExample>


# Update an integration
Source: https://v0.x-docs.novu.co/api-reference/integrations/update-integration

put /v1/integrations/{integrationId}
Update an integration by its unique key identifier **integrationId**. 
    Each provider supports different credentials, check the provider documentation for more details. Only integration metadata is returned, credentials field is returned as an empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu, ProvidersIdEnum } from '@novu/node'; 

  const novu = new Novu('<NOVU_API_KEY>');

  const updatePayload = {
    name: "SendGrid",
    identifier: "sendgrid-identifier",
    credentials: {
      apiKey: "SUPER_SECRET_API_KEY",
      from: "no-reply@novu.co",
      senderName: "Novu Team"
      // ... other credentials as per provider
    },
    active: true,
    check: false
  }

  await novu.integrations.getWebhookProviderStatus(ProvidersIdEnum.SendGrid, updatePayload);
  ```

  ```php PHP theme={null}
  // Get integrations
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->updateIntegration($integrationId, [
      'active' => true,
      'credentials' => [
          // insert all the fields
      ],
      'check' => true
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  body = {
      'active' => true,
      'check' => true
      'credentials' => {
          # insert all the fields
      },
  }
  client.update_integration('<insert-provider-id>', body)
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).update(
      integration="<The instance of the integration to update>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.updateIntegration(integrationId, body);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "_environmentId": "string",
      "_organizationId": "string",
      "name": "string",
      "identifier": "string",
      "providerId": "string",
      "channel": "in_app",
      "credentials": {
        "apiKey": "string",
        "user": "string",
        "secretKey": "string",
        "domain": "string",
        "password": "string",
        "host": "string",
        "port": "string",
        "secure": true,
        "region": "string",
        "accountSid": "string",
        "messageProfileId": "string",
        "token": "string",
        "from": "string",
        "senderName": "string",
        "projectName": "string",
        "applicationId": "string",
        "clientId": "string",
        "requireTls": true,
        "ignoreTls": true,
        "tlsOptions": {},
        "baseUrl": "string",
        "webhookUrl": "string",
        "redirectUrl": "string",
        "hmac": true,
        "serviceAccount": "string",
        "ipPoolName": "string"
      },
      "active": true,
      "deleted": true,
      "deletedAt": "string",
      "deletedBy": "string",
      "primary": true
    }
  }
  ```
</ResponseExample>


# Delete layout
Source: https://v0.x-docs.novu.co/api-reference/layouts/delete-layout

delete /v1/layouts/{layoutId}
Execute a soft delete of a layout given a certain ID.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.layouts.delete("layoutId");
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.delete_layout('<insert-layout-id>')
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).delete(
      layout_id="<Layout_ID to identify the layout to be deleted>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.deleteLayout(layoutId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      204: "The layout has been deleted correctly",
      404: "The layout with the layoutId provided does not exist in the database so it can not be deleted.",
      409: "Either you are trying to delete a layout that is being used or a layout that is the default in the environment."
  }
  ```
</ResponseExample>


# Filter layouts
Source: https://v0.x-docs.novu.co/api-reference/layouts/filter-layouts

get /v1/layouts
Returns a list of layouts that can be paginated using the `page` query parameter and filtered by the environment where it is executed from the organization the user belongs to.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  const params = {
    page: 0, // optional
    pageSize: 20, // optional
    sortBy: "_id"
    orderBy: -1 //optional
  }

  await novu.layouts.list(params);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.layouts({
      'page' => 1, # optional
      'pageSize' => 10, # optional
      'sortBy' => 'createdAt', # optional
      'orderBy' => 1 # optional
  })
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).list(
      page="<Page number for pagination>",
      limit="Size of each page",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.layouts(query = {});
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      data: ["data"],
      page: 0,
      pageSize: 0,
      totalCount: 0
  }
  ```
</ResponseExample>


# Get layout
Source: https://v0.x-docs.novu.co/api-reference/layouts/get-layout

get /v1/layouts/{layoutId}
Get a layout by its ID

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.layouts.get("layoutId");
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  body = {
      'active' => true,
      'check' => true
      'credentials' => {
          # insert all the fields
      },
  }
  client.layout('<insert-layout-id>')
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).get(
      layout_id="<The layout ID>"
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.layout(layoutId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "_organizationId": "string",
      "_environmentId": "string",
      "_creatorId": "string",
      "name": "string",
      "identifier": "string",
      "description": "string",
      "channel": "in_app",
      "content": "string",
      "contentType": "string",
      "variables": [
        {}
      ],
      "isDefault": true,
      "isDeleted": true,
      "createdAt": "string",
      "updatedAt": "string",
      "_parentId": "string"
    }
  }
  ```
</ResponseExample>


# Layout creation
Source: https://v0.x-docs.novu.co/api-reference/layouts/layout-creation

post /v1/layouts
Create a layout

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  const payload = {
    content: "<h1>Layout Start</h1>{{{body}}}<h1>Layout End</h1>",
    description: "Organisation's first layout",
    name: "First Layout",
    identifier: "firstlayout",
    variables: [
      {
        type: "String",
        name: "body"
        required: true
        defValue: ""
      }
    ]
    isDefault: "false"
  }
  await novu.layouts.create(payload);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  payload = {
      'name' => 'New layout',
      'content' => '{{{body}}}',
      'variables' => ['<list-variables-here>'], # optional
      'description' => 'This is a description for the new layout', # optional
      'isDefault' => true # optional
  }
  client.create_layout(payload)
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).create(
      layout="<The instance of the layout to create>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.createLayout(body);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
      "_id": "Layout identifier"
    }
  }
  ```
</ResponseExample>


# Set default layout
Source: https://v0.x-docs.novu.co/api-reference/layouts/set-default-layout

post /v1/layouts/{layoutId}/default
Sets the default layout for the environment and updates to non default to the existing default layout (if any).

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.layouts.setDefault("layoutId");
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.make_default_layout('<insert-layout-id>')
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).set_default(
      layout_id= "<The layout_id corresponding to the layout to be set default>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.makeDefaultLayout(layoutId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      204: "The selected layout has been set as the default for the environment."

      404: "The layout with the layoutId provided does not exist in the database so it can not be set as the default for the environment."
  }
  ```
</ResponseExample>


# Update a layout
Source: https://v0.x-docs.novu.co/api-reference/layouts/update-a-layout

patch /v1/layouts/{layoutId}
Update the name, content and variables of a layout. Also change it to be default or no.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  const payloadToUpdate = {
    content: "<h1>Layout Start</h1>{{{body}}}<h1>Layout End</h1>",
    description: "Organisation's first layout",
    name: "First Layout",
    identifier: "firstlayout",
    variables: [
      {
        type: "String",
        name: "body"
        required: true
        defValue: ""
      }
    ]
    isDefault: false
  }
  await novu.layouts.update("layoutId", payloadToUpdate);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  payload = {
      'name' => 'Update layout', # optional
      'content' => '{{{body}}}', # optional
      'description' => 'This is a description for the new layout', # optional
      'isDefault' => true # optional
      'variables' => ['<list-variables-here>'], # optional
  }
  client.update_layout('<insert-layout-id>', payload)
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).patch(
      layout= "<The instance of the layout to be updated>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.updateLayout(layoutId, body);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "name": "string",
    "identifier": "string",
    "description": "string",
    "content": "string",
    "variables": [
      {}
    ],
    "isDefault": true
  }
  ```
</ResponseExample>


# Delete a message
Source: https://v0.x-docs.novu.co/api-reference/messages/delete-message

delete /v1/messages/{messageId}
Delete a message entity from the Novu platform by **messageId**. 
    This action is irreversible. **messageId** is required and of mongodbId type.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu, ChannelTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.messages.deleteById("<Message_Id>");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu("<NOVU_API_KEY>");

  $novu->deleteMessage();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.delete_message('<insert-message-id>')
  ```

  ```python Python theme={null}
  from novu.api import MessageApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = MessageApi(url, api_key).delete(
      message_id= "The message ID to delete",    
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.deleteMessage(messageId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "acknowledged": true,
      "status": "deleted"
    }
  }
  ```
</ResponseExample>


# Delete messages by transactionId
Source: https://v0.x-docs.novu.co/api-reference/messages/delete-message-by-transactionid

delete /v1/messages/transaction/{transactionId}
Delete multiple messages from the Novu platform using **transactionId** of triggered event. 
    This API supports filtering by **channel** and delete all messages associated with the **transactionId**.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```cURL theme={null}
  curl --request DELETE \
  --url 'https://api.novu.co/v1/messages/transaction/{transactionId}' \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```
</RequestExample>

<ResponseExample>
  ```json theme={null}
  204 - No Content
  ```
</ResponseExample>


# List all messages
Source: https://v0.x-docs.novu.co/api-reference/messages/get-messages

get /v1/messages
List all messages for the current environment. 
    This API supports filtering by **channel**, **subscriberId**, and **transactionId**. 
    This API returns a paginated list of messages.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu, ChannelTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  const params = {
    page: 0, // optional
    limit: 20, // optional
    subscriberId: "subscriberId"  //optional
    channel: ChannelTypeEnum.EMAIL //optional
    transactionIds : ["txnId1","txnId2"] //optional
  }

  await novu.messages.list(params);
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu("<NOVU_API_KEY>");

  $novu->getMessages();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'channel' => 'slack', # optional
      'subscriberId' => '7789', # optional
      'transactionId' =>'sw900999as', # optional
      'page' => 4, # optional
      'limit' => 10, # optional
  }
  client.messages(payload)
  ```

  ```python Python theme={null}
  from novu.api import MessageApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = MessageApi(url, api_key).list(
      limit= "The number of messages to fetch, defaults to 10",
      page= "The page to fetch, defaults to 0",
      channel = "The channel for the messages you wish to list. Defaults to None.",
      subscriber_id = "The subscriberId for the subscriber you like to list messages for",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.messages(query = {});
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      hasMore: true,
      data: [data],
      pageSize: 0,
      page: 0
  }
  ```
</ResponseExample>


# Create an organization
Source: https://v0.x-docs.novu.co/api-reference/organizations/create-organization

post /v1/organizations

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Remove a member from organization using memberId
Source: https://v0.x-docs.novu.co/api-reference/organizations/delete-member-from-organization

delete /v1/organizations/members/{memberId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Fetch all members of current organizations
Source: https://v0.x-docs.novu.co/api-reference/organizations/get-all-members-of-current-organization

get /v1/organizations/members

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Fetch all organizations
Source: https://v0.x-docs.novu.co/api-reference/organizations/get-all-organizations

get /v1/organizations

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Fetch current organization details
Source: https://v0.x-docs.novu.co/api-reference/organizations/get-current-organization

get /v1/organizations/me

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Rename organization name
Source: https://v0.x-docs.novu.co/api-reference/organizations/rename-organization

patch /v1/organizations

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update member role to admin
Source: https://v0.x-docs.novu.co/api-reference/organizations/update-member-role-to-admin

put /v1/organizations/members/{memberId}/roles

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update organization branding details
Source: https://v0.x-docs.novu.co/api-reference/organizations/update-organization-branding

put /v1/organizations/branding

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Create tenant
Source: https://v0.x-docs.novu.co/api-reference/tenants/create-tenant

post /v1/tenants
Create tenant under the current environment

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Delete tenant
Source: https://v0.x-docs.novu.co/api-reference/tenants/delete-tenant

delete /v1/tenants/{identifier}
Deletes a tenant entity from the Novu platform

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get tenant
Source: https://v0.x-docs.novu.co/api-reference/tenants/get-tenant

get /v1/tenants/{identifier}
Get tenant by your internal id used to identify the tenant

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get tenants
Source: https://v0.x-docs.novu.co/api-reference/tenants/get-tenants

get /v1/tenants
Returns a list of tenants, could paginated using the `page` and `limit` query parameter

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update tenant
Source: https://v0.x-docs.novu.co/api-reference/tenants/update-tenant

patch /v1/tenants/{identifier}
Update tenant by your internal id used to identify the tenant

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Create workflow group
Source: https://v0.x-docs.novu.co/api-reference/workflow-groups/create-workflow-group

post /v1/notification-groups
workflow group was previously named notification group

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request POST \
  --url https://api.novu.co/v1/notification-groups \
  --header 'Authorization: ApiKey <NOVU_API_KEY>' \
  --header 'Content-Type: application/json' \
  --data '{"name": "insert-name"}'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationGroups.create("Product Updates");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->createNotificationGroup([
      'name' => '<insert-name>'
  ]);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.create_notification_group({
      'name' => '<insert-name>'
  })
  ```

  ```python Python theme={null}
  from novu.api import NotificationGroupApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationGroupApi(url, api_key).create(
      name = "<The name of the notification group>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.createWorkflowGroup(body);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/notification-groups"
    data := map[string]string{
      "name": "name"
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "_environmentId": "string",
      "_organizationId": "string",
      "_parentId": "string"
    }
  }
  ```
</ResponseExample>


# Delete workflow group
Source: https://v0.x-docs.novu.co/api-reference/workflow-groups/delete-workflow-group

delete /v1/notification-groups/{id}
workflow group was previously named notification group

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request DELETE \
  --url https://api.novu.co/v1/notification-groups/{id} \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationGroups.delete("notificationGroupId");
  ```

  ```php PHP theme={null}
  <?php

  $url = 'https://api.novu.co/v1/notification-groups/:id';
  $data = array(
    [options]
  );
  $options = array(
    "http" => array(
    "header"  => "Content-type: application/json",
    "header"  => "Authorization: ApiKey REPLACE_WITH_API_KEY",
    "method"  => "DELETE",
    "content" => json_encode($data)
    )
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);

  if ($result === FALSE) { /* Handle error */ }

  echo $result;
      
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'uri'

  uri = URI.parse('https://api.novu.co/v1/notification-groups/:id')
  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri)

  request.body = '{
    [options]
  }'
  request.content_type = 'application/json'
  request.add_field('Authorization', 'ApiKey REPLACE_WITH_API_KEY')


  response = http.request(request)

  puts response.body
      
  ```

  ```python Python theme={null}
  import requests

  response = requests.delete('https://api.novu.co/v1/notification-groups/:id')

  print(response.json())
      
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/notification-groups/:id"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("DELETE", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "acknowledged": true,
      "status": "deleted"
    }
  }
  ```
</ResponseExample>


# Get workflow group
Source: https://v0.x-docs.novu.co/api-reference/workflow-groups/get-workflow-group

get /v1/notification-groups/{id}
workflow group was previously named notification group

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notification-groups/{id} \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationGroups.getOne("notificationGroupId");
  ```

  ```php PHP theme={null}
  <?php

  $url = 'https://api.novu.co/v1/notification-groups/:id';
  $data = array(
    [options]
  );
  $options = array(
    "http" => array(
    "header"  => "Content-type: application/json",
    "header"  => "Authorization: ApiKey REPLACE_WITH_API_KEY",
    "method"  => "GET",
    "content" => json_encode($data)
    )
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);

  if ($result === FALSE) { /* Handle error */ }

  echo $result;
      
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'uri'

  uri = URI.parse('https://api.novu.co/v1/notification-groups/:id')
  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri)

  request.body = '{
    [options]
  }'
  request.content_type = 'application/json'
  request.add_field('Authorization', 'ApiKey REPLACE_WITH_API_KEY')


  response = http.request(request)

  puts response.body
      
  ```

  ```python Python theme={null}
  import requests

  response = requests.get('https://api.novu.co/v1/notification-groups/:id')

  print(response.json())
      
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/notification-groups/:id"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("GET", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}

    "data": {
      "_id": "string",
      "name": "string",
      "_environmentId": "string",
      "_organizationId": "string",
      "_parentId": "string"
    }
  }
  ```
</ResponseExample>


# Update workflow group
Source: https://v0.x-docs.novu.co/api-reference/workflow-groups/update-workflow-group

patch /v1/notification-groups/{id}
workflow group was previously named notification group

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request PATCH \
  --url https://api.novu.co/v1/notification-groups/{id} \
  --header 'Authorization: ApiKey <NOVU_API_KEY>' \
  --header 'Content-Type: application/json' \
  --data '{"name": "insert-new-name"}'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationGroups.update("notificationGroupId", { name: "Changelog Updates"});
  ```

  ```php PHP theme={null}
  <?php

  $url = 'https://api.novu.co/v1/notification-groups/:id';
  $data = array(
    "name": "name"
  );
  $options = array(
    "http" => array(
    "header"  => "Content-type: application/json",
    "header"  => "Authorization: ApiKey REPLACE_WITH_API_KEY",
    "method"  => "PATCH",
    "content" => json_encode($data)
    )
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);

  if ($result === FALSE) { /* Handle error */ }

  echo $result;
      
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'uri'

  uri = URI.parse('https://api.novu.co/v1/notification-groups/:id')
  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri)

  request.body = '{
    "name": "name"
  }'
  request.content_type = 'application/json'
  request.add_field('Authorization', 'ApiKey REPLACE_WITH_API_KEY')


  response = http.request(request)

  puts response.body
      
  ```

  ```python Python theme={null}
  import requests

  response = requests.patch('https://api.novu.co/v1/notification-groups/:id', json={
        "name": "name",
  }, headers={
      'Content-Type': 'application/json'
      'Authorization': 'ApiKey REPLACE_WITH_API_KEY'
  })

  print(response.json())
      
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.updateWorkflowGroup(workflowId, body);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/notification-groups/:id"
    data := map[string]string{
      "name": "name"
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("PATCH", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "_environmentId": "string",
      "_organizationId": "string",
      "_parentId": "string"
    }
  }
  ```
</ResponseExample>


# Novu Architecture Diagram
Source: https://v0.x-docs.novu.co/architecture/diagrams



# Novu Architecture Diagram powered by [terrastruct](https://terrastruct.com) and D2

If the diagram below is not rendering, please [click here](https://app.terrastruct.com/diagrams/1895866270) to view it on terrastruct.com.

<iframe title="Novu" />


# Introduction to Novu
Source: https://v0.x-docs.novu.co/architecture/introduction

Overview of Novu's Architecture

Novu is an open-source notification infrastructure designed to provide a robust, efficient, and flexible solution for managing notifications across various platforms.
The architecture of Novu is meticulously crafted to ensure accurate delivery of notifications while maintaining high performance and scalability.

Our systems are hosted on Amazon Web Services (AWS), ensuring a reliable and secure environment for our infrastructure.
We adhere to several industry-standard compliance certifications including SOC II, PCI, and GDPR which underline our commitment to security and data privacy.

## Framework Leveraged

* **Nestjs**: A progressive Node.js framework that is used for building efficient, reliable, and scalable server-side applications. Nestjs provides a high-level abstraction with a lot of out-of-the-box features, making it a perfect choice for building modular and maintainable applications.
* **Mongoose**: An elegant Object Document Mapper (ODM) for MongoDB, which simplifies the interaction with the database by providing a straightforward modeling of the application data. Mongoose’s features like schema validation, query building, and middleware support immensely help in building robust applications.
* **BullMQ**: A robust, fast, and reliable queue library for handling distributed jobs and messages in Node.js. It is instrumental in managing the processing of notification jobs ensuring they are handled in an efficient and reliable manner.

## Databases

* **MongoDB**: A NoSQL database that provides high performance, high availability, and easy scalability. It works on a document-oriented data model, which is extremely flexible and allows for varied, complex data structures to be stored and manipulated with ease.
* **Redis**: An in-memory data structure store, used as a database, cache, and message broker. It's exceptionally fast and provides support for various data structures like strings, hashes, lists, sets, etc. It's utilized in Novu for caching and as a reliable message broker for managing queues and real-time data processing.

## Scalability & Performance

The architecture of Novu is designed to scale horizontally to handle a growing number of notification requests. The use of microservices, container orchestration with Kubernetes, and leveraging AWS’s auto-scaling capabilities, ensure that the system can handle high loads while maintaining low latency and high throughput.

## Monitoring & Observability

Monitoring and observability are crucial for ensuring the reliable operation of Novu. Utilizing tools like Prometheus and Grafana, we've built a comprehensive monitoring and alerting system that provides real-time insights into the system’s performance and health.

## Security

Security is a paramount concern in Novu’s architecture. By adhering to industry-standard security practices and compliance certifications, we ensure that the data flowing through Novu is handled securely and in compliance with regulatory requirements.


# Concepts
Source: https://v0.x-docs.novu.co/getting-started/concepts

Learn about the key concepts of Novu

## Notification

A notification conveys information from source to recipient, triggered by a workflow acting as a message blueprint. Notifications can be individual or bundled as [digest](/workflows/digest) for user-friendliness.

## Messages

A message in Novu represents a notification delivered to a recipient on a particular channel. Messages contain information about the request that triggered its delivery, a view of the data sent to the recipient, and a timeline of its lifecycle events. [Learn more about messages](/workflows/messages).

## Workflow

All notifications are sent via a workflow. Each workflow acts as a container for the logic and blueprint that are associated with a type of notification in your system. [Learn more](/workflows/notification-workflows)

## Channel

A channel in Novu represents a configured provider, such as Sendgrid for email, to send notifications to your recipients. A channel is the communication-context domain with the recipients (subscribers).

Most providers within Novu use credentials that you supply to deliver notifications on your behalf. These credentials and other settings are what make a configured channel. [Learn more](/channels-and-providers/introduction)

## Subscriber

A subscriber in Novu represents someone who should receive a message. A subscriber's profile information contains important attributes about the subscriber that will be used in messages (name, email). The subscriber object can contain other key-value pairs that can be used to further personalize your messages. [Learn more about subscribers.](/subscribers/subscribers)

## Topics

Topics are a way to group subscribers together so that they can be notified of events at once. A topic is identified by a custom key. This can be helpful for things like sending out marketing emails or notifying users of new features. Topics can also be used to send notifications to the subscribers who have been grouped together based on their interests, location, activities and much more. [Learn more about topics.](/subscribers/topics)

## Activity Feed

Novu provides a notification activity feed that monitors every outgoing message associated with its relevant metadata. This can be used to monitor activity and discover potential issues with a specific provider or a channel type. [Learn more about the activity feed.](/activity-feed/introduction)

## Integration Store

With the help of the integration store, you can easily integrate your favorite delivery provider. During the runtime of the API, the Integrations Store is responsible for storing the configurations of all the providers. [Learn more](/channels-and-providers/integration-store)

## Providers

Providers are the channel service providers (Twilio, Sendgrid, APN, etc,) you connect to Novu so that it can send your notifications. Rather than replacing your existing providers, Novu passes your notifications to the providers you already use via these channel integrations. [Learn more about providers.](/channels-and-providers/introduction)

## Environment

* Production
* Development

Novu uses the concept of environments to ensure logical separation of your data and configuration. This means that subscribers, and preferences created in one environment are **never** accessible to another. [Learn more about environments.](/platform/environments)

## Handlebars & Helpers

Handlebars is a simple templating language that generates HTML.

Novu-specific Helpers make it possible to define custom iterators and other functionality that can invoke the passed block with a new context. [Learn more about helpers.](/content-creation-design/handlebars-helpers)

## Organization

An organization serves as a separate entity within your Novu account. Each organization you create has its own separate integration store, workflows, subscribers, and API keys. This separation of resources allows you to manage multi-tenant environments and separate domains within a single account.

Switching your organization in the UI only affects the UI and does not deactivate any organizations on the API side. Moreover, the message delivery for each organization operates simultaneously.

Keep in mind that workflows and integration stores for one organization cannot be used for subscribers of other organizations.

<img />

To create a new organization, you interact with a drop down menu in the bottom of the left navigation bar within Novu’s application. Type the name of your new organization, and if the name is new, you will see a button that enables you to add a new one.

<img />

To switch between organizations, you again interact with the same drop down menu and switch between the organizations you have in your Novu account.

<img />

## Notification Center

Notification Center is a beautifully designed and highly functional in-app experience for your users that you can add to your product quickly and effortlessly.

The core components of our Notification Center are:

* A list of notifications with real-time updates
* Notification preference management
* State management and actions for notifications (mark as read/unread, and delete)
* And more

[Learn more](/notification-center/introduction)

## Preference

A preference indicates a user's willingness to receive a particular type of notification. Preferences always belong to a user and can be paired with an identifier that represents the account or tenant that the user belongs to (for multi-tenant applications). [Learn more](/subscribers/preferences)

## Delay Actions

The delay action awaits a specified amount of time before moving on to trigger the following steps of the workflow. [Learn more](/workflows/delay-action)

## Digest

The digest engine collects multiple trigger events, aggregates them into a single message and delivers it to the subscriber. [Learn more](/workflows/digest)

## Layouts

Novu allows the creation of layouts - a specific HTML design or structure to wrap content of email notifications. Layouts can be manipulated and assigned to new or existing workflows within the Novu platform, allowing users to create, manage, and assign these layouts to workflows, so they can be reused to structure the appearance of notifications sent through the platform. [Learn more](/content-creation-design/layouts)

## Tenants

A tenant represents a group of users. As a developer, when your apps have organizations, they are referred to as tenants. Tenants in Novu provides the ability to tailor specific notification experiences to users of different **groups** or **organizations**. [Learn more about Novu Tenants.](/tenants/introduction)


# How Does Novu Work?
Source: https://v0.x-docs.novu.co/getting-started/how-novu-works



Novu comprises two fundamental components: an API for data exchange and a dashboard for designing notifications and their accompanying logical rules.

This section provides a broad overview of Novu's functionality, delving into key concepts for your initial Novu journey. If you prefer to dive into development, explore our **[Quick Start guides](/quickstarts/overview)**.

## Architecture

Novu's Object Communication Layer (OCL) is a structured framework that separates communication tasks into specialized components.
Similar to microservices, these components handle specific roles like message passing and data management. By doing so, OCL enhances system maintenance and scalability, making it easier to integrate new functionalities.

Novu's approach goes beyond this, optimizing communication protocols for seamless collaboration and adaptability. It's like providing a playbook for coordinating a dynamic game, ensuring all players are synchronized for any challenge.

<img />


# What is Novu?
Source: https://v0.x-docs.novu.co/getting-started/introduction

Novu is a full-stack (UI, API & GitOps) open source notification infrastructure tool and platform for building, managing, delivering, and monitoring all types of end-user notifications.

Novu supports a variety of common notification channels out-of-the-box, including **email**, **SMS**, **push**, **in-app**, and **chat**. Our platform is a developer-first product built for engineers that need to simplify the complexities of notification management, while working closely with product and marketing teams that need to provide, edit, and maintain notification content.

<AccordionGroup>
  <Accordion title="Get started with our quickstarts">
    Get started in minutes

    <CardGroup>
      <Card title="React" icon="react" href="/quickstarts/react">
        Embed a real-time notification center component in your React application.
      </Card>

      <Card title="Vue" icon="vuejs" href="/quickstarts/vue">
        Embed a real-time notification center component in your Vue application.
      </Card>

      <Card title="Angular" icon="angular" href="/quickstarts/angular">
        Embed a real-time notification center component in your Angular application.
      </Card>

      <Card
        title="Kotlin"
        icon={
<svg
    xmlns="http://www.w3.org/2000/svg"
    width="20"
    height="20"
    viewBox="0 0 256 256"
  >
    <defs>
      <linearGradient
        id="logosKotlinIcon0"
        x1="99.991%"
        x2=".01%"
        y1="-.011%"
        y2="100.01%"
      >
        <stop offset=".344%" stopColor="#E44857" />
        <stop offset="46.89%" stopColor="#C711E1" />
        <stop offset="100%" stopColor="#7F52FF" />
      </linearGradient>
    </defs>
    <path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosKotlinIcon0)" d="M256 256H0V0h256L128 127.949z" />
  </svg>}
        href="/quickstarts/kotlin"
      >
        Embed a real-time notification center component in your Kotlin application.
      </Card>

      <Card
        title="PHP"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#deviconPhp0)" d="M0 64c0 18.593 28.654 33.667 64 33.667c35.346 0 64-15.074 64-33.667c0-18.593-28.655-33.667-64-33.667C28.654 30.333 0 45.407 0 64Z"/><path fill="#777bb3" d="M64 95.167c33.965 0 61.5-13.955 61.5-31.167c0-17.214-27.535-31.167-61.5-31.167S2.5 46.786 2.5 64c0 17.212 27.535 31.167 61.5 31.167Z"/><path d="M34.772 67.864c2.793 0 4.877-.515 6.196-1.53c1.306-1.006 2.207-2.747 2.68-5.175c.44-2.27.272-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.464l-2.473 12.732zM20.173 83.547a.694.694 0 0 1-.68-.828l6.557-33.738a.695.695 0 0 1 .68-.561h14.134c4.442 0 7.748 1.206 9.827 3.585c2.088 2.39 2.734 5.734 1.917 9.935c-.333 1.711-.905 3.3-1.7 4.724a15.818 15.818 0 0 1-3.128 3.92c-1.531 1.432-3.264 2.472-5.147 3.083c-1.852.604-4.232.91-7.07.91h-5.724l-1.634 8.408a.695.695 0 0 1-.682.562z"/><path fill="#fff" d="M34.19 55.826h3.891c3.107 0 4.186.682 4.553 1.089c.607.674.723 2.097.331 4.112c-.439 2.257-1.253 3.858-2.42 4.756c-1.194.92-3.138 1.386-5.773 1.386h-2.786l2.205-11.342zm6.674-8.1H26.731a1.39 1.39 0 0 0-1.364 1.123L18.81 82.588a1.39 1.39 0 0 0 1.363 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.151c2.912 0 5.364-.318 7.287-.944c1.977-.642 3.796-1.731 5.406-3.237a16.522 16.522 0 0 0 3.259-4.087c.831-1.487 1.429-3.147 1.775-4.931c.86-4.423.161-7.964-2.076-10.524c-2.216-2.537-5.698-3.823-10.349-3.823zM30.301 68.557h4.471c2.963 0 5.17-.557 6.62-1.675c1.451-1.116 2.428-2.98 2.938-5.591c.485-2.508.264-4.277-.665-5.308c-.931-1.03-2.791-1.546-5.584-1.546h-5.036l-2.743 14.12m10.563-19.445c4.252 0 7.353 1.117 9.303 3.348c1.95 2.232 2.536 5.347 1.76 9.346c-.322 1.648-.863 3.154-1.625 4.518c-.764 1.366-1.76 2.614-2.991 3.747c-1.468 1.373-3.097 2.352-4.892 2.935c-1.794.584-4.08.875-6.857.875h-6.296l-1.743 8.97h-7.35l6.558-33.739h14.133"/><path d="M69.459 74.577a.694.694 0 0 1-.682-.827l2.9-14.928c.277-1.42.209-2.438-.19-2.87c-.245-.263-.979-.704-3.15-.704h-5.256l-3.646 18.768a.695.695 0 0 1-.683.56h-7.29a.695.695 0 0 1-.683-.826l6.558-33.739a.695.695 0 0 1 .682-.561h7.29a.695.695 0 0 1 .683.826L64.41 48.42h5.653c4.307 0 7.227.758 8.928 2.321c1.733 1.593 2.275 4.14 1.608 7.573l-3.051 15.702a.695.695 0 0 1-.682.56h-7.407z"/><path fill="#fff" d="M65.31 38.755h-7.291a1.39 1.39 0 0 0-1.364 1.124l-6.557 33.738a1.39 1.39 0 0 0 1.363 1.654h7.291a1.39 1.39 0 0 0 1.364-1.124l3.537-18.205h4.682c2.168 0 2.624.463 2.641.484c.132.14.305.795.019 2.264l-2.9 14.927a1.39 1.39 0 0 0 1.364 1.654h7.408a1.39 1.39 0 0 0 1.363-1.124l3.051-15.7c.715-3.686.103-6.45-1.82-8.217c-1.836-1.686-4.91-2.505-9.398-2.505h-4.81l1.421-7.315a1.39 1.39 0 0 0-1.364-1.655zm0 1.39l-1.743 8.968h6.496c4.087 0 6.907.714 8.457 2.14c1.553 1.426 2.017 3.735 1.398 6.93l-3.052 15.699h-7.407l2.901-14.928c.33-1.698.208-2.856-.365-3.474c-.573-.617-1.793-.926-3.658-.926h-5.829l-3.756 19.327H51.46l6.558-33.739h7.292z"/><path d="M92.136 67.864c2.793 0 4.878-.515 6.198-1.53c1.304-1.006 2.206-2.747 2.679-5.175c.44-2.27.273-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.463l-2.475 12.732zM77.54 83.547a.694.694 0 0 1-.682-.828l6.557-33.738a.695.695 0 0 1 .682-.561H98.23c4.442 0 7.748 1.206 9.826 3.585c2.089 2.39 2.734 5.734 1.917 9.935a15.878 15.878 0 0 1-1.699 4.724a15.838 15.838 0 0 1-3.128 3.92c-1.53 1.432-3.265 2.472-5.147 3.083c-1.852.604-4.232.91-7.071.91h-5.723l-1.633 8.408a.695.695 0 0 1-.683.562z"/><path fill="#fff" d="M91.555 55.826h3.891c3.107 0 4.186.682 4.552 1.089c.61.674.724 2.097.333 4.112c-.44 2.257-1.254 3.858-2.421 4.756c-1.195.92-3.139 1.386-5.773 1.386h-2.786l2.204-11.342zm6.674-8.1H84.096a1.39 1.39 0 0 0-1.363 1.123l-6.558 33.739a1.39 1.39 0 0 0 1.364 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.15c2.911 0 5.364-.318 7.286-.944c1.978-.642 3.797-1.731 5.408-3.238a16.52 16.52 0 0 0 3.258-4.086c.832-1.487 1.428-3.147 1.775-4.931c.86-4.423.162-7.964-2.076-10.524c-2.216-2.537-5.697-3.823-10.35-3.823zM87.666 68.557h4.47c2.964 0 5.17-.557 6.622-1.675c1.45-1.116 2.428-2.98 2.936-5.591c.487-2.508.266-4.277-.665-5.308c-.93-1.03-2.791-1.546-5.583-1.546h-5.035Zm10.563-19.445c4.251 0 7.354 1.117 9.303 3.348c1.95 2.232 2.537 5.347 1.759 9.346c-.32 1.648-.862 3.154-1.624 4.518c-.763 1.366-1.76 2.614-2.992 3.747c-1.467 1.373-3.097 2.352-4.892 2.935c-1.793.584-4.078.875-6.856.875h-6.295l-1.745 8.97h-7.35l6.558-33.739h14.133"/><defs><radialGradient id="deviconPhp0" cx="0" cy="0" r="1" gradientTransform="translate(38.426 42.169) scale(84.04136)" gradientUnits="userSpaceOnUse"><stop stopColor="#AEB2D5"/><stop offset=".3" stopColor="#AEB2D5"/><stop offset=".75" stopColor="#484C89"/><stop offset="1" stopColor="#484C89"/></radialGradient></defs></svg>
}
        href="/quickstarts/php"
      >
        Embed a real-time notification center component in your PHP application.
      </Card>

      <Card
        title="Ruby"
        icon={<svg xmlns="http://www.w3.org/2000/svg" width="20" height="19.93" viewBox="0 0 256 255"><defs><linearGradient id="logosRuby0" x1="84.75%" x2="58.254%" y1="111.399%" y2="64.584%"><stop offset="0%" stopColor="#FB7655"/><stop offset="0%" stopColor="#FB7655"/><stop offset="41%" stopColor="#E42B1E"/><stop offset="99%" stopColor="#900"/><stop offset="100%" stopColor="#900"/></linearGradient><linearGradient id="logosRuby1" x1="116.651%" x2="1.746%" y1="60.89%" y2="19.288%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby2" x1="75.774%" x2="38.978%" y1="219.327%" y2="7.829%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby3" x1="50.012%" x2="66.483%" y1="7.234%" y2="79.135%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E57252"/><stop offset="46%" stopColor="#DE3B20"/><stop offset="99%" stopColor="#A60003"/><stop offset="100%" stopColor="#A60003"/></linearGradient><linearGradient id="logosRuby4" x1="46.174%" x2="49.932%" y1="16.348%" y2="83.047%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E4714E"/><stop offset="56%" stopColor="#BE1A0D"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby5" x1="36.965%" x2="49.528%" y1="15.594%" y2="92.478%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="18%" stopColor="#E46342"/><stop offset="40%" stopColor="#C82410"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby6" x1="13.609%" x2="85.764%" y1="58.346%" y2="-46.717%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="54%" stopColor="#C81F11"/><stop offset="99%" stopColor="#BF0905"/><stop offset="100%" stopColor="#BF0905"/></linearGradient><linearGradient id="logosRuby7" x1="27.624%" x2="50.745%" y1="21.135%" y2="79.056%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="31%" stopColor="#DE4024"/><stop offset="99%" stopColor="#BF190B"/><stop offset="100%" stopColor="#BF190B"/></linearGradient><linearGradient id="logosRuby8" x1="-20.667%" x2="104.242%" y1="122.282%" y2="-6.342%"><stop offset="0%" stopColor="#BD0012"/><stop offset="0%" stopColor="#BD0012"/><stop offset="7%" stopColor="#FFF"/><stop offset="17%" stopColor="#FFF"/><stop offset="27%" stopColor="#C82F1C"/><stop offset="33%" stopColor="#820C01"/><stop offset="46%" stopColor="#A31601"/><stop offset="72%" stopColor="#B31301"/><stop offset="99%" stopColor="#E82609"/><stop offset="100%" stopColor="#E82609"/></linearGradient><linearGradient id="logosRuby9" x1="58.792%" x2="11.964%" y1="65.205%" y2="50.128%"><stop offset="0%" stopColor="#8C0C01"/><stop offset="0%" stopColor="#8C0C01"/><stop offset="54%" stopColor="#990C00"/><stop offset="99%" stopColor="#A80D0E"/><stop offset="100%" stopColor="#A80D0E"/></linearGradient><linearGradient id="logosRubya" x1="79.319%" x2="23.088%" y1="62.754%" y2="17.888%"><stop offset="0%" stopColor="#7E110B"/><stop offset="0%" stopColor="#7E110B"/><stop offset="99%" stopColor="#9E0C00"/><stop offset="100%" stopColor="#9E0C00"/></linearGradient><linearGradient id="logosRubyb" x1="92.88%" x2="59.841%" y1="74.122%" y2="39.704%"><stop offset="0%" stopColor="#79130D"/><stop offset="0%" stopColor="#79130D"/><stop offset="99%" stopColor="#9E120B"/><stop offset="100%" stopColor="#9E120B"/></linearGradient><linearGradient id="logosRubyc" x1="56.57%" x2="3.105%" y1="101.717%" y2="11.993%"><stop offset="0%" stopColor="#8B2114"/><stop offset="0%" stopColor="#8B2114"/><stop offset="43%" stopColor="#9E100A"/><stop offset="99%" stopColor="#B3100C"/><stop offset="100%" stopColor="#B3100C"/></linearGradient><linearGradient id="logosRubyd" x1="30.87%" x2="92.471%" y1="35.599%" y2="100.694%"><stop offset="0%" stopColor="#B31000"/><stop offset="0%" stopColor="#B31000"/><stop offset="44%" stopColor="#910F08"/><stop offset="99%" stopColor="#791C12"/><stop offset="100%" stopColor="#791C12"/></linearGradient><radialGradient id="logosRubye" cx="32.001%" cy="40.21%" r="69.573%" fx="32.001%" fy="40.21%"><stop offset="0%" stopColor="#A80D00"/><stop offset="0%" stopColor="#A80D00"/><stop offset="99%" stopColor="#7E0E08"/><stop offset="100%" stopColor="#7E0E08"/></radialGradient><radialGradient id="logosRubyf" cx="13.549%" cy="40.86%" r="88.386%" fx="13.549%" fy="40.86%"><stop offset="0%" stopColor="#A30C00"/><stop offset="0%" stopColor="#A30C00"/><stop offset="99%" stopColor="#800E08"/><stop offset="100%" stopColor="#800E08"/></radialGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby0)" d="m197.467 167.764l-145.52 86.41l188.422-12.787L254.88 51.393l-57.414 116.37Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby1)" d="M240.677 241.257L224.482 129.48l-44.113 58.25l60.308 53.528Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby2)" d="m240.896 241.257l-118.646-9.313l-69.674 21.986l188.32-12.673Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby3)" d="m52.744 253.955l29.64-97.1L17.16 170.8l35.583 83.154Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby4)" d="M180.358 188.05L153.085 81.226l-78.047 73.16l105.32 33.666Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby5)" d="m248.693 82.73l-73.777-60.256l-20.544 66.418l94.321-6.162Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby6)" d="M214.191.99L170.8 24.97L143.424.669l70.767.322Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby7)" d="m0 203.372l18.177-33.151l-14.704-39.494L0 203.372Z"/><path fill="#FFF" d="m2.496 129.48l14.794 41.963l64.283-14.422l73.39-68.207l20.712-65.787L143.063 0L87.618 20.75c-17.469 16.248-51.366 48.396-52.588 49c-1.21.618-22.384 40.639-32.534 59.73Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby8)" d="M54.442 54.094c37.86-37.538 86.667-59.716 105.397-40.818c18.72 18.898-1.132 64.823-38.992 102.349c-37.86 37.525-86.062 60.925-104.78 42.027c-18.73-18.885.515-66.032 38.375-103.558Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby9)" d="m52.744 253.916l29.408-97.409l97.665 31.376c-35.312 33.113-74.587 61.106-127.073 66.033Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubya)" d="m155.092 88.622l25.073 99.313c29.498-31.016 55.972-64.36 68.938-105.603l-94.01 6.29Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyb)" d="M248.847 82.833c10.035-30.282 12.35-73.725-34.966-81.791l-38.825 21.445l73.791 60.346Z"/><path fill="#9E1209" d="M0 202.935c1.39 49.979 37.448 50.724 52.808 51.162l-35.48-82.86L0 202.935Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubye)" d="M155.232 88.777c22.667 13.932 68.35 41.912 69.276 42.426c1.44.81 19.695-30.784 23.838-48.64l-93.114 6.214Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyf)" d="m82.113 156.507l39.313 75.848c23.246-12.607 41.45-27.967 58.121-44.42l-97.434-31.428Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyc)" d="m17.174 171.34l-5.57 66.328c10.51 14.357 24.97 15.605 40.136 14.486c-10.973-27.311-32.894-81.92-34.566-80.814Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyd)" d="m174.826 22.654l78.1 10.96c-4.169-17.662-16.969-29.06-38.787-32.623l-39.313 21.663Z"/></svg>

}
        href="/quickstarts/ruby"
      >
        Embed a real-time notification center component in your Ruby application.
      </Card>
    </CardGroup>
  </Accordion>

  <Accordion title="Explore our SDKs">
    You can interface with Novu's API either over REST, or via libraries for certain languages. Below is a list of our official, supported libraries.

    ### Client Side

    The Client side libraries and components helps to add a fully functional notification center to your application.

    <CardGroup>
      <Card title="React" icon="react" href="/sdks/react">
        Embed a real-time notification center component in your React application.
      </Card>

      <Card title="Vue" icon="vuejs" href="/sdks/vue">
        Embed a real-time notification center component in your Vue application.
      </Card>

      <Card title="Angular" icon="angular" href="/sdks/angular">
        Embed a real-time notification center component in your Angular application.
      </Card>

      <Card title="Web Component" icon="square-js" href="/sdks/web-component">
        Embed a real-time notification center component in your JavaScript application.
      </Card>

      <Card title="IFrame Embed" icon="frame" href="/sdks/iframe-embed">
        Embed a real-time notification center inside an iframe using our embedded script.
      </Card>

      <Card title="Headless JavaScript" icon="js" href="/sdks/headless-javascript-service">
        Embed a notification system into any framework or vanilla JavaScript project, without being constrained by our default UI or dependencies.
      </Card>
    </CardGroup>

    ### Server Side

    The Server Side libraries help to trigger notifications and interact with all of Novu’s API seamlessly.

    <CardGroup>
      <Card
        title="Node.js"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="21.47" viewBox="0 0 512 314"><defs><linearGradient id="logosNodejs0" x1="68.188%" x2="27.823%" y1="17.487%" y2="89.755%"><stop offset="0%" stopColor="#41873F"/><stop offset="32.88%" stopColor="#418B3D"/><stop offset="63.52%" stopColor="#419637"/><stop offset="93.19%" stopColor="#3FA92D"/><stop offset="100%" stopColor="#3FAE2A"/></linearGradient><linearGradient id="logosNodejs1" x1="43.277%" x2="159.245%" y1="55.169%" y2="-18.306%"><stop offset="13.76%" stopColor="#41873F"/><stop offset="40.32%" stopColor="#54A044"/><stop offset="71.36%" stopColor="#66B848"/><stop offset="90.81%" stopColor="#6CC04A"/></linearGradient><linearGradient id="logosNodejs2" x1="-4413.77%" x2="5327.93%" y1="13.43%" y2="13.43%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs3" x1="-4.389%" x2="101.499%" y1="49.997%" y2="49.997%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs4" x1="-9713.77%" x2="27.93%" y1="36.21%" y2="36.21%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs5" x1="-103.861%" x2="100.797%" y1="50.275%" y2="50.275%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs6" x1="130.613%" x2="4.393%" y1="-211.069%" y2="201.605%"><stop offset="0%" stopColor="#41873F"/><stop offset="32.88%" stopColor="#418B3D"/><stop offset="63.52%" stopColor="#419637"/><stop offset="93.19%" stopColor="#3FA92D"/><stop offset="100%" stopColor="#3FAE2A"/></linearGradient><path id="logosNodejs7" d="M57.903 1.85a5.957 5.957 0 0 0-5.894 0L3.352 29.933c-1.85 1.04-2.89 3.005-2.89 5.085v56.286c0 2.08 1.156 4.045 2.89 5.085l48.657 28.085a5.957 5.957 0 0 0 5.894 0l48.658-28.085c1.849-1.04 2.89-3.005 2.89-5.085V35.019c0-2.08-1.157-4.045-2.89-5.085L57.903 1.85Z"/></defs><g fill="none"><path fill="#539E43" d="M253.11 313.094c-1.733 0-3.351-.462-4.854-1.271l-15.371-9.13c-2.312-1.272-1.156-1.734-.462-1.965c3.12-1.04 3.698-1.272 6.934-3.12c.347-.232.81-.116 1.156.115l11.789 7.05c.462.231 1.04.231 1.386 0l46.115-26.698c.462-.231.694-.694.694-1.271v-53.28c0-.579-.232-1.04-.694-1.272l-46.115-26.582c-.462-.232-1.04-.232-1.386 0l-46.115 26.582c-.462.231-.694.809-.694 1.271v53.28c0 .463.232 1.04.694 1.272l12.598 7.281c6.819 3.467 11.095-.578 11.095-4.623v-52.587c0-.693.578-1.387 1.387-1.387h5.894c.694 0 1.387.578 1.387 1.387v52.587c0 9.13-4.97 14.447-13.638 14.447c-2.658 0-4.738 0-10.633-2.89l-12.135-6.934c-3.005-1.733-4.854-4.97-4.854-8.437v-53.28c0-3.467 1.849-6.704 4.854-8.437l46.114-26.698c2.89-1.618 6.82-1.618 9.709 0l46.114 26.698c3.005 1.733 4.855 4.97 4.855 8.437v53.28c0 3.467-1.85 6.704-4.855 8.437l-46.114 26.698c-1.503.694-3.236 1.04-4.854 1.04Zm14.216-36.637c-20.225 0-24.386-9.246-24.386-17.105c0-.694.578-1.387 1.387-1.387h6.01c.693 0 1.271.462 1.271 1.156c.925 6.125 3.583 9.13 15.834 9.13c9.708 0 13.87-2.196 13.87-7.397c0-3.005-1.157-5.2-16.297-6.703c-12.598-1.272-20.457-4.045-20.457-14.1c0-9.362 7.86-14.91 21.035-14.91c14.793 0 22.075 5.086 23 16.18c0 .348-.116.694-.347 1.041c-.232.231-.578.462-.925.462h-6.01c-.578 0-1.156-.462-1.271-1.04c-1.387-6.356-4.97-8.437-14.447-8.437c-10.633 0-11.905 3.699-11.905 6.472c0 3.352 1.503 4.392 15.834 6.241c14.216 1.85 20.92 4.508 20.92 14.447c-.116 10.171-8.437 15.95-23.116 15.95Z"/><path fill="#333" d="M110.028 104.712c0-2.08-1.156-4.046-3.005-5.086l-49.004-28.2c-.81-.463-1.734-.694-2.658-.81h-.463c-.924 0-1.849.347-2.658.81l-49.004 28.2c-1.85 1.04-3.005 3.005-3.005 5.086l.116 75.817c0 1.04.578 2.08 1.502 2.543c.925.578 2.08.578 2.89 0l29.125-16.643c1.849-1.04 3.005-3.005 3.005-5.085v-35.482c0-2.08 1.155-4.045 3.005-5.085l12.366-7.166c.925-.578 1.965-.81 3.005-.81c1.04 0 2.08.232 2.89.81l12.366 7.166c1.85 1.04 3.005 3.004 3.005 5.085v35.482c0 2.08 1.156 4.045 3.005 5.085l29.125 16.643a2.82 2.82 0 0 0 3.005 0c.925-.463 1.503-1.503 1.503-2.543l-.116-75.817ZM345.571.347c-.924-.463-2.08-.463-2.89 0c-.924.578-1.502 1.502-1.502 2.542v75.125c0 .693-.346 1.386-1.04 1.849c-.693.346-1.387.346-2.08 0l-12.251-7.05a5.957 5.957 0 0 0-5.895 0l-49.004 28.316c-1.849 1.04-3.005 3.005-3.005 5.085v56.516c0 2.08 1.156 4.046 3.005 5.086l49.004 28.316a5.957 5.957 0 0 0 5.895 0l49.004-28.316c1.849-1.04 3.005-3.005 3.005-5.086V21.844c0-2.196-1.156-4.16-3.005-5.201L345.572.347Zm-4.507 143.776c0 .578-.231 1.04-.694 1.271l-16.758 9.708a1.714 1.714 0 0 1-1.503 0l-16.758-9.708c-.463-.231-.694-.809-.694-1.271v-19.417c0-.578.231-1.04.694-1.271l16.758-9.709a1.714 1.714 0 0 1 1.503 0l16.758 9.709c.463.23.694.809.694 1.271v19.417Zm167.584-19.879c1.85-1.04 2.89-3.005 2.89-5.086v-13.753c0-2.08-1.156-4.045-2.89-5.085l-48.657-28.2a5.957 5.957 0 0 0-5.895 0l-49.004 28.315c-1.85 1.04-3.005 3.005-3.005 5.085v56.517c0 2.08 1.156 4.045 3.005 5.085l48.657 27.738c1.85 1.04 4.046 1.04 5.78 0L489 178.45c.925-.463 1.503-1.503 1.503-2.543c0-1.04-.578-2.08-1.503-2.543l-49.235-28.316c-.925-.578-1.503-1.502-1.503-2.542v-17.683c0-1.04.578-2.08 1.503-2.543l15.371-8.784a2.821 2.821 0 0 1 3.005 0l15.372 8.784c.925.578 1.502 1.502 1.502 2.543v13.869c0 1.04.578 2.08 1.503 2.542a2.82 2.82 0 0 0 3.005 0l29.125-16.99Z"/><path fill="#539E43" d="M456.292 121.585a1.05 1.05 0 0 1 1.156 0l9.362 5.432c.346.232.577.578.577 1.04v10.865c0 .462-.23.809-.577 1.04l-9.362 5.432a1.05 1.05 0 0 1-1.156 0l-9.361-5.432c-.347-.231-.578-.578-.578-1.04v-10.864c0-.463.23-.81.578-1.04l9.361-5.433Z"/><g transform="translate(134.068 70.501)"><mask id="logosNodejs8" fill="#fff"><use href="#logosNodejs7"/></mask><use fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs0)" href="#logosNodejs7"/><g mask="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs8)"><path d="M51.893 1.85L3.121 29.933C1.27 30.974 0 32.94 0 35.02v56.286c0 1.387.578 2.658 1.502 3.698L56.285 1.156c-1.387-.231-3.005-.116-4.392.693Zm4.739 123.203c.462-.116.925-.347 1.387-.578l48.773-28.085c1.85-1.04 3.005-3.005 3.005-5.085V35.019c0-1.502-.694-3.005-1.734-4.045l-51.43 94.079Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs1)" d="M106.676 29.934L57.788 1.85a8.025 8.025 0 0 0-1.503-.578L1.502 95.12a6.082 6.082 0 0 0 1.619 1.387l48.888 28.085c1.387.809 3.005 1.04 4.507.577l51.432-94.078c-.347-.462-.81-.81-1.272-1.156Z"/></g><g mask="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs8)"><path d="M109.797 91.305V35.019c0-2.08-1.271-4.045-3.12-5.085L57.786 1.85a5.106 5.106 0 0 0-1.848-.693l53.511 91.42c.231-.347.347-.809.347-1.271ZM3.12 29.934C1.272 30.974 0 32.94 0 35.02v56.286c0 2.08 1.387 4.045 3.12 5.085l48.889 28.085c1.156.693 2.427.925 3.814.693L3.467 29.818l-.346.116Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs2)" fillRule="evenodd" d="m50.391.809l-.693.347h.924l-.231-.347Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs3)" fillRule="evenodd" d="M106.792 105.636c1.387-.809 2.427-2.196 2.89-3.698L56.053 10.402c-1.387-.231-2.89-.116-4.16.693L3.351 39.065l52.355 95.465a8.057 8.057 0 0 0 2.196-.693l48.889-28.2Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs4)" fillRule="evenodd" d="m111.3 104.712l-.347-.578v.809l.346-.231Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs5)" fillRule="evenodd" d="m106.792 105.636l-48.773 28.085a6.973 6.973 0 0 1-2.196.693l.925 1.734l54.089-31.32v-.694l-1.387-2.312c-.231 1.618-1.271 3.005-2.658 3.814Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs6)" fillRule="evenodd" d="m106.792 105.636l-48.773 28.085a6.973 6.973 0 0 1-2.196.693l.925 1.734l54.089-31.32v-.694l-1.387-2.312c-.231 1.618-1.271 3.005-2.658 3.814Z" transform="translate(0 -9.246)"/></g></g></g></svg>
}
        href="/sdks/nodejs"
      >
        Connect your Node app to Novu via the Node.js SDK.
      </Card>

      <Card
        title="Go"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="13.13" viewBox="0 0 512 192"><path fill="#00ACD7" d="m292.533 13.295l1.124.75c13.212 8.725 22.685 20.691 28.917 35.15c1.496 2.243.499 3.49-2.493 4.237l-5.063 1.296c-11.447 2.949-20.53 5.429-31.827 8.378l-6.443 1.678c-2.32.574-2.96.333-5.428-2.477l-.348-.399c-3.519-3.988-6.155-6.652-10.817-9.03l-.899-.443c-15.705-7.727-30.911-5.484-45.12 3.74c-16.952 10.968-25.677 27.172-25.428 47.364c.25 19.942 13.96 36.395 33.654 39.137c16.951 2.244 31.16-3.739 42.378-16.452c2.244-2.743 4.238-5.734 6.73-9.224h-48.11c-5.235 0-6.481-3.24-4.736-7.478l.864-2.035c3.204-7.454 8.173-18.168 11.4-24.294l.704-1.319c.862-1.494 2.612-3.513 5.977-3.513h80.224c3.603-11.415 9.449-22.201 17.246-32.407c18.198-23.931 40.135-36.396 69.8-41.63c25.427-4.488 49.359-1.995 71.046 12.713c19.694 13.461 31.909 31.66 35.15 55.59c4.237 33.654-5.485 61.075-28.668 84.508c-16.453 16.702-36.645 27.172-59.829 31.908c-6.73 1.247-13.461 1.496-19.942 2.244c-22.685-.499-43.376-6.98-60.826-21.937c-12.273-10.61-20.727-23.648-24.928-38.828a104.937 104.937 0 0 1-10.47 16.89c-17.949 23.683-41.381 38.39-71.046 42.38c-24.43 3.24-47.115-1.497-67.058-16.454c-18.447-13.96-28.917-32.407-31.66-55.34c-3.24-27.173 4.737-51.603 21.19-73.041c17.7-23.184 41.132-37.891 69.8-43.126c22.999-4.16 45.037-1.595 64.936 11.464ZM411.12 49.017l-.798.178c-23.183 5.235-38.14 19.942-43.624 43.375c-4.488 19.444 4.985 39.138 22.934 47.115c13.71 5.983 27.421 5.235 40.633-1.496c19.694-10.22 30.413-26.175 31.66-47.613c-.25-3.24-.25-5.734-.749-8.227c-4.436-24.401-26.664-38.324-50.056-33.332ZM116.416 94.564c.997 0 1.496.748 1.496 1.745l-.499 5.983c0 .997-.997 1.745-1.745 1.745l-54.344-.249c-.997 0-1.246-.748-.748-1.496l3.49-6.232c.499-.748 1.496-1.496 2.493-1.496h49.857ZM121.9 71.63c.997 0 1.496.748 1.247 1.496l-1.995 5.983c-.249.997-1.246 1.495-2.243 1.495l-117.912.25c-.997 0-1.246-.499-.748-1.247l5.235-6.73c.499-.748 1.745-1.247 2.742-1.247H121.9Zm12.963-22.934c.997 0 1.246.748.748 1.496l-4.238 6.481c-.499.748-1.745 1.496-2.493 1.496l-90.24-.25c-.998 0-1.247-.498-.749-1.246l5.235-6.73c.499-.748 1.745-1.247 2.742-1.247h88.995Z"/></svg>
}
        href="/sdks/go"
      >
        Connect your Golang app to Novu via the Go SDK.
      </Card>

      <Card
        title="PHP"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#deviconPhp0)" d="M0 64c0 18.593 28.654 33.667 64 33.667c35.346 0 64-15.074 64-33.667c0-18.593-28.655-33.667-64-33.667C28.654 30.333 0 45.407 0 64Z"/><path fill="#777bb3" d="M64 95.167c33.965 0 61.5-13.955 61.5-31.167c0-17.214-27.535-31.167-61.5-31.167S2.5 46.786 2.5 64c0 17.212 27.535 31.167 61.5 31.167Z"/><path d="M34.772 67.864c2.793 0 4.877-.515 6.196-1.53c1.306-1.006 2.207-2.747 2.68-5.175c.44-2.27.272-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.464l-2.473 12.732zM20.173 83.547a.694.694 0 0 1-.68-.828l6.557-33.738a.695.695 0 0 1 .68-.561h14.134c4.442 0 7.748 1.206 9.827 3.585c2.088 2.39 2.734 5.734 1.917 9.935c-.333 1.711-.905 3.3-1.7 4.724a15.818 15.818 0 0 1-3.128 3.92c-1.531 1.432-3.264 2.472-5.147 3.083c-1.852.604-4.232.91-7.07.91h-5.724l-1.634 8.408a.695.695 0 0 1-.682.562z"/><path fill="#fff" d="M34.19 55.826h3.891c3.107 0 4.186.682 4.553 1.089c.607.674.723 2.097.331 4.112c-.439 2.257-1.253 3.858-2.42 4.756c-1.194.92-3.138 1.386-5.773 1.386h-2.786l2.205-11.342zm6.674-8.1H26.731a1.39 1.39 0 0 0-1.364 1.123L18.81 82.588a1.39 1.39 0 0 0 1.363 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.151c2.912 0 5.364-.318 7.287-.944c1.977-.642 3.796-1.731 5.406-3.237a16.522 16.522 0 0 0 3.259-4.087c.831-1.487 1.429-3.147 1.775-4.931c.86-4.423.161-7.964-2.076-10.524c-2.216-2.537-5.698-3.823-10.349-3.823zM30.301 68.557h4.471c2.963 0 5.17-.557 6.62-1.675c1.451-1.116 2.428-2.98 2.938-5.591c.485-2.508.264-4.277-.665-5.308c-.931-1.03-2.791-1.546-5.584-1.546h-5.036l-2.743 14.12m10.563-19.445c4.252 0 7.353 1.117 9.303 3.348c1.95 2.232 2.536 5.347 1.76 9.346c-.322 1.648-.863 3.154-1.625 4.518c-.764 1.366-1.76 2.614-2.991 3.747c-1.468 1.373-3.097 2.352-4.892 2.935c-1.794.584-4.08.875-6.857.875h-6.296l-1.743 8.97h-7.35l6.558-33.739h14.133"/><path d="M69.459 74.577a.694.694 0 0 1-.682-.827l2.9-14.928c.277-1.42.209-2.438-.19-2.87c-.245-.263-.979-.704-3.15-.704h-5.256l-3.646 18.768a.695.695 0 0 1-.683.56h-7.29a.695.695 0 0 1-.683-.826l6.558-33.739a.695.695 0 0 1 .682-.561h7.29a.695.695 0 0 1 .683.826L64.41 48.42h5.653c4.307 0 7.227.758 8.928 2.321c1.733 1.593 2.275 4.14 1.608 7.573l-3.051 15.702a.695.695 0 0 1-.682.56h-7.407z"/><path fill="#fff" d="M65.31 38.755h-7.291a1.39 1.39 0 0 0-1.364 1.124l-6.557 33.738a1.39 1.39 0 0 0 1.363 1.654h7.291a1.39 1.39 0 0 0 1.364-1.124l3.537-18.205h4.682c2.168 0 2.624.463 2.641.484c.132.14.305.795.019 2.264l-2.9 14.927a1.39 1.39 0 0 0 1.364 1.654h7.408a1.39 1.39 0 0 0 1.363-1.124l3.051-15.7c.715-3.686.103-6.45-1.82-8.217c-1.836-1.686-4.91-2.505-9.398-2.505h-4.81l1.421-7.315a1.39 1.39 0 0 0-1.364-1.655zm0 1.39l-1.743 8.968h6.496c4.087 0 6.907.714 8.457 2.14c1.553 1.426 2.017 3.735 1.398 6.93l-3.052 15.699h-7.407l2.901-14.928c.33-1.698.208-2.856-.365-3.474c-.573-.617-1.793-.926-3.658-.926h-5.829l-3.756 19.327H51.46l6.558-33.739h7.292z"/><path d="M92.136 67.864c2.793 0 4.878-.515 6.198-1.53c1.304-1.006 2.206-2.747 2.679-5.175c.44-2.27.273-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.463l-2.475 12.732zM77.54 83.547a.694.694 0 0 1-.682-.828l6.557-33.738a.695.695 0 0 1 .682-.561H98.23c4.442 0 7.748 1.206 9.826 3.585c2.089 2.39 2.734 5.734 1.917 9.935a15.878 15.878 0 0 1-1.699 4.724a15.838 15.838 0 0 1-3.128 3.92c-1.53 1.432-3.265 2.472-5.147 3.083c-1.852.604-4.232.91-7.071.91h-5.723l-1.633 8.408a.695.695 0 0 1-.683.562z"/><path fill="#fff" d="M91.555 55.826h3.891c3.107 0 4.186.682 4.552 1.089c.61.674.724 2.097.333 4.112c-.44 2.257-1.254 3.858-2.421 4.756c-1.195.92-3.139 1.386-5.773 1.386h-2.786l2.204-11.342zm6.674-8.1H84.096a1.39 1.39 0 0 0-1.363 1.123l-6.558 33.739a1.39 1.39 0 0 0 1.364 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.15c2.911 0 5.364-.318 7.286-.944c1.978-.642 3.797-1.731 5.408-3.238a16.52 16.52 0 0 0 3.258-4.086c.832-1.487 1.428-3.147 1.775-4.931c.86-4.423.162-7.964-2.076-10.524c-2.216-2.537-5.697-3.823-10.35-3.823zM87.666 68.557h4.47c2.964 0 5.17-.557 6.622-1.675c1.45-1.116 2.428-2.98 2.936-5.591c.487-2.508.266-4.277-.665-5.308c-.93-1.03-2.791-1.546-5.583-1.546h-5.035Zm10.563-19.445c4.251 0 7.354 1.117 9.303 3.348c1.95 2.232 2.537 5.347 1.759 9.346c-.32 1.648-.862 3.154-1.624 4.518c-.763 1.366-1.76 2.614-2.992 3.747c-1.467 1.373-3.097 2.352-4.892 2.935c-1.793.584-4.078.875-6.856.875h-6.295l-1.745 8.97h-7.35l6.558-33.739h14.133"/><defs><radialGradient id="deviconPhp0" cx="0" cy="0" r="1" gradientTransform="translate(38.426 42.169) scale(84.04136)" gradientUnits="userSpaceOnUse"><stop stopColor="#AEB2D5"/><stop offset=".3" stopColor="#AEB2D5"/><stop offset=".75" stopColor="#484C89"/><stop offset="1" stopColor="#484C89"/></radialGradient></defs></svg>
}
        href="/sdks/php"
      >
        Connect your PHP app to Novu via the PHP SDK.
      </Card>

      <Card title="Laravel" icon="laravel" href="/sdks/laravel">
        Connect your Laravel app to Novu via the Laravel SDK.
      </Card>

      <Card
        title=".NET"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 256 256"><g fill="none"><rect width="256" height="256" fill="#512BD4" rx="60"/><path fill="#fff" d="M24.052 168.943c-2.236 0-4.138-.731-5.703-2.194c-1.566-1.501-2.349-3.283-2.349-5.347c0-2.101.783-3.902 2.349-5.403c1.565-1.5 3.466-2.251 5.703-2.251c2.274 0 4.194.751 5.76 2.251c1.603 1.501 2.404 3.302 2.404 5.403c0 2.064-.801 3.846-2.404 5.347c-1.566 1.463-3.486 2.194-5.76 2.194Zm89.415-1.238H98.929l-38.304-59.318a26.371 26.371 0 0 1-2.404-4.672h-.336c.298 1.726.447 5.422.447 11.087v52.903H45.471V87H60.96l37.018 57.912c1.566 2.402 2.572 4.052 3.02 4.953h.223c-.372-2.139-.559-5.759-.559-10.863V87h12.805v80.705Zm62.631 0h-45.014V87h43.225v11.369h-29.916v22.849h27.568v11.312h-27.568v23.863h31.705v11.312Zm63.973-69.336h-23.038v69.336h-13.309V98.369h-22.982V87h59.329v11.369Z"/></g></svg>
}
        href="/sdks/dotnet"
      >
        Connect your C#/.NET app to Novu via the .NET SDK.
      </Card>

      <Card
        title="Ruby"
        icon={
       <svg xmlns="http://www.w3.org/2000/svg" width="20" height="19.93" viewBox="0 0 256 255"><defs><linearGradient id="logosRuby0" x1="84.75%" x2="58.254%" y1="111.399%" y2="64.584%"><stop offset="0%" stopColor="#FB7655"/><stop offset="0%" stopColor="#FB7655"/><stop offset="41%" stopColor="#E42B1E"/><stop offset="99%" stopColor="#900"/><stop offset="100%" stopColor="#900"/></linearGradient><linearGradient id="logosRuby1" x1="116.651%" x2="1.746%" y1="60.89%" y2="19.288%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby2" x1="75.774%" x2="38.978%" y1="219.327%" y2="7.829%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby3" x1="50.012%" x2="66.483%" y1="7.234%" y2="79.135%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E57252"/><stop offset="46%" stopColor="#DE3B20"/><stop offset="99%" stopColor="#A60003"/><stop offset="100%" stopColor="#A60003"/></linearGradient><linearGradient id="logosRuby4" x1="46.174%" x2="49.932%" y1="16.348%" y2="83.047%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E4714E"/><stop offset="56%" stopColor="#BE1A0D"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby5" x1="36.965%" x2="49.528%" y1="15.594%" y2="92.478%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="18%" stopColor="#E46342"/><stop offset="40%" stopColor="#C82410"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby6" x1="13.609%" x2="85.764%" y1="58.346%" y2="-46.717%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="54%" stopColor="#C81F11"/><stop offset="99%" stopColor="#BF0905"/><stop offset="100%" stopColor="#BF0905"/></linearGradient><linearGradient id="logosRuby7" x1="27.624%" x2="50.745%" y1="21.135%" y2="79.056%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="31%" stopColor="#DE4024"/><stop offset="99%" stopColor="#BF190B"/><stop offset="100%" stopColor="#BF190B"/></linearGradient><linearGradient id="logosRuby8" x1="-20.667%" x2="104.242%" y1="122.282%" y2="-6.342%"><stop offset="0%" stopColor="#BD0012"/><stop offset="0%" stopColor="#BD0012"/><stop offset="7%" stopColor="#FFF"/><stop offset="17%" stopColor="#FFF"/><stop offset="27%" stopColor="#C82F1C"/><stop offset="33%" stopColor="#820C01"/><stop offset="46%" stopColor="#A31601"/><stop offset="72%" stopColor="#B31301"/><stop offset="99%" stopColor="#E82609"/><stop offset="100%" stopColor="#E82609"/></linearGradient><linearGradient id="logosRuby9" x1="58.792%" x2="11.964%" y1="65.205%" y2="50.128%"><stop offset="0%" stopColor="#8C0C01"/><stop offset="0%" stopColor="#8C0C01"/><stop offset="54%" stopColor="#990C00"/><stop offset="99%" stopColor="#A80D0E"/><stop offset="100%" stopColor="#A80D0E"/></linearGradient><linearGradient id="logosRubya" x1="79.319%" x2="23.088%" y1="62.754%" y2="17.888%"><stop offset="0%" stopColor="#7E110B"/><stop offset="0%" stopColor="#7E110B"/><stop offset="99%" stopColor="#9E0C00"/><stop offset="100%" stopColor="#9E0C00"/></linearGradient><linearGradient id="logosRubyb" x1="92.88%" x2="59.841%" y1="74.122%" y2="39.704%"><stop offset="0%" stopColor="#79130D"/><stop offset="0%" stopColor="#79130D"/><stop offset="99%" stopColor="#9E120B"/><stop offset="100%" stopColor="#9E120B"/></linearGradient><linearGradient id="logosRubyc" x1="56.57%" x2="3.105%" y1="101.717%" y2="11.993%"><stop offset="0%" stopColor="#8B2114"/><stop offset="0%" stopColor="#8B2114"/><stop offset="43%" stopColor="#9E100A"/><stop offset="99%" stopColor="#B3100C"/><stop offset="100%" stopColor="#B3100C"/></linearGradient><linearGradient id="logosRubyd" x1="30.87%" x2="92.471%" y1="35.599%" y2="100.694%"><stop offset="0%" stopColor="#B31000"/><stop offset="0%" stopColor="#B31000"/><stop offset="44%" stopColor="#910F08"/><stop offset="99%" stopColor="#791C12"/><stop offset="100%" stopColor="#791C12"/></linearGradient><radialGradient id="logosRubye" cx="32.001%" cy="40.21%" r="69.573%" fx="32.001%" fy="40.21%"><stop offset="0%" stopColor="#A80D00"/><stop offset="0%" stopColor="#A80D00"/><stop offset="99%" stopColor="#7E0E08"/><stop offset="100%" stopColor="#7E0E08"/></radialGradient><radialGradient id="logosRubyf" cx="13.549%" cy="40.86%" r="88.386%" fx="13.549%" fy="40.86%"><stop offset="0%" stopColor="#A30C00"/><stop offset="0%" stopColor="#A30C00"/><stop offset="99%" stopColor="#800E08"/><stop offset="100%" stopColor="#800E08"/></radialGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby0)" d="m197.467 167.764l-145.52 86.41l188.422-12.787L254.88 51.393l-57.414 116.37Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby1)" d="M240.677 241.257L224.482 129.48l-44.113 58.25l60.308 53.528Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby2)" d="m240.896 241.257l-118.646-9.313l-69.674 21.986l188.32-12.673Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby3)" d="m52.744 253.955l29.64-97.1L17.16 170.8l35.583 83.154Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby4)" d="M180.358 188.05L153.085 81.226l-78.047 73.16l105.32 33.666Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby5)" d="m248.693 82.73l-73.777-60.256l-20.544 66.418l94.321-6.162Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby6)" d="M214.191.99L170.8 24.97L143.424.669l70.767.322Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby7)" d="m0 203.372l18.177-33.151l-14.704-39.494L0 203.372Z"/><path fill="#FFF" d="m2.496 129.48l14.794 41.963l64.283-14.422l73.39-68.207l20.712-65.787L143.063 0L87.618 20.75c-17.469 16.248-51.366 48.396-52.588 49c-1.21.618-22.384 40.639-32.534 59.73Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby8)" d="M54.442 54.094c37.86-37.538 86.667-59.716 105.397-40.818c18.72 18.898-1.132 64.823-38.992 102.349c-37.86 37.525-86.062 60.925-104.78 42.027c-18.73-18.885.515-66.032 38.375-103.558Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby9)" d="m52.744 253.916l29.408-97.409l97.665 31.376c-35.312 33.113-74.587 61.106-127.073 66.033Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubya)" d="m155.092 88.622l25.073 99.313c29.498-31.016 55.972-64.36 68.938-105.603l-94.01 6.29Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyb)" d="M248.847 82.833c10.035-30.282 12.35-73.725-34.966-81.791l-38.825 21.445l73.791 60.346Z"/><path fill="#9E1209" d="M0 202.935c1.39 49.979 37.448 50.724 52.808 51.162l-35.48-82.86L0 202.935Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubye)" d="M155.232 88.777c22.667 13.932 68.35 41.912 69.276 42.426c1.44.81 19.695-30.784 23.838-48.64l-93.114 6.214Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyf)" d="m82.113 156.507l39.313 75.848c23.246-12.607 41.45-27.967 58.121-44.42l-97.434-31.428Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyc)" d="m17.174 171.34l-5.57 66.328c10.51 14.357 24.97 15.605 40.136 14.486c-10.973-27.311-32.894-81.92-34.566-80.814Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyd)" d="m174.826 22.654l78.1 10.96c-4.169-17.662-16.969-29.06-38.787-32.623l-39.313 21.663Z"/></svg>

}
        href="/sdks/ruby"
      >
        Connect your Ruby app to Novu via the Ruby SDK.
      </Card>

      <Card
        title="Java"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="#0074BD" d="M47.617 98.12s-4.767 2.774 3.397 3.71c9.892 1.13 14.947.968 25.845-1.092c0 0 2.871 1.795 6.873 3.351c-24.439 10.47-55.308-.607-36.115-5.969zm-2.988-13.665s-5.348 3.959 2.823 4.805c10.567 1.091 18.91 1.18 33.354-1.6c0 0 1.993 2.025 5.132 3.131c-29.542 8.64-62.446.68-41.309-6.336z"/><path fill="#EA2D2E" d="M69.802 61.271c6.025 6.935-1.58 13.17-1.58 13.17s15.289-7.891 8.269-17.777c-6.559-9.215-11.587-13.792 15.635-29.58c0 .001-42.731 10.67-22.324 34.187z"/><path fill="#0074BD" d="M102.123 108.229s3.529 2.91-3.888 5.159c-14.102 4.272-58.706 5.56-71.094.171c-4.451-1.938 3.899-4.625 6.526-5.192c2.739-.593 4.303-.485 4.303-.485c-4.953-3.487-32.013 6.85-13.743 9.815c49.821 8.076 90.817-3.637 77.896-9.468zM49.912 70.294s-22.686 5.389-8.033 7.348c6.188.828 18.518.638 30.011-.326c9.39-.789 18.813-2.474 18.813-2.474s-3.308 1.419-5.704 3.053c-23.042 6.061-67.544 3.238-54.731-2.958c10.832-5.239 19.644-4.643 19.644-4.643zm40.697 22.747c23.421-12.167 12.591-23.86 5.032-22.285c-1.848.385-2.677.72-2.677.72s.688-1.079 2-1.543c14.953-5.255 26.451 15.503-4.823 23.725c0-.002.359-.327.468-.617z"/><path fill="#EA2D2E" d="M76.491 1.587S89.459 14.563 64.188 34.51c-20.266 16.006-4.621 25.13-.007 35.559c-11.831-10.673-20.509-20.07-14.688-28.815C58.041 28.42 81.722 22.195 76.491 1.587z"/><path fill="#0074BD" d="M52.214 126.021c22.476 1.437 57-.8 57.817-11.436c0 0-1.571 4.032-18.577 7.231c-19.186 3.612-42.854 3.191-56.887.874c0 .001 2.875 2.381 17.647 3.331z"/></svg>
}
        href="/sdks/java"
      >
        Connect your Java app to Novu via the Java SDK.
      </Card>

      <Card
        title="Kotlin"
        icon={
  <svg
    xmlns="http://www.w3.org/2000/svg"
    width="20"
    height="20"
    viewBox="0 0 256 256"
  >
    <defs>
      <linearGradient
        id="logosKotlinIcon0"
        x1="99.991%"
        x2=".01%"
        y1="-.011%"
        y2="100.01%"
      >
        <stop offset=".344%" stopColor="#E44857" />
        <stop offset="46.89%" stopColor="#C711E1" />
        <stop offset="100%" stopColor="#7F52FF" />
      </linearGradient>
    </defs>
    <path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosKotlinIcon0)" d="M256 256H0V0h256L128 127.949z" />
  </svg>
}
        href="/sdks/kotlin"
      >
        Connect your Kotlin app to Novu via the Kotlin SDK.
      </Card>

      <Card
        title="Python"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="34.87" viewBox="0 0 256 255"><defs><linearGradient id="logosPython0" x1="12.959%" x2="79.639%" y1="12.039%" y2="78.201%"><stop offset="0%" stopColor="#387EB8"/><stop offset="100%" stopColor="#366994"/></linearGradient><linearGradient id="logosPython1" x1="19.128%" x2="90.742%" y1="20.579%" y2="88.429%"><stop offset="0%" stopColor="#FFE052"/><stop offset="100%" stopColor="#FFC331"/></linearGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosPython0)" d="M126.916.072c-64.832 0-60.784 28.115-60.784 28.115l.072 29.128h61.868v8.745H41.631S.145 61.355.145 126.77c0 65.417 36.21 63.097 36.21 63.097h21.61v-30.356s-1.165-36.21 35.632-36.21h61.362s34.475.557 34.475-33.319V33.97S194.67.072 126.916.072ZM92.802 19.66a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.13Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosPython1)" d="M128.757 254.126c64.832 0 60.784-28.115 60.784-28.115l-.072-29.127H127.6v-8.745h86.441s41.486 4.705 41.486-60.712c0-65.416-36.21-63.096-36.21-63.096h-21.61v30.355s1.165 36.21-35.632 36.21h-61.362s-34.475-.557-34.475 33.32v56.013s-5.235 33.897 62.518 33.897Zm34.114-19.586a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.131a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13Z"/></svg>
}
        href="/sdks/python"
      >
        Connect your Python app to Novu via the Python SDK.
      </Card>
    </CardGroup>
  </Accordion>
</AccordionGroup>

The [Novu Cloud SaaS](https://web.novu.co) platform provides an intuitive internal user interface, embeddable UI end-user components, and a hybrid code-first workflow capability.

Novu eliminates the significant burden of building, hosting, and managing a notifications infrastructure that all modern software businesses need in order to notify and engage staff, end users, and customers.

## Notification types

Novu supports different notification types, including user-generated and machine-generated notifications.

### Machine generated

* Triggered by some automated action—think a container pod scaling event.
* Notify one or more end users (which can be internal users, of course!).
* Often can be voluminous, so digests are helpful.

### Product notifications

* Triggered by end-user interactions and events within your product.
* Notify one or more subscribers.
* Typically transactional, such as order updates, password resets, account verifications, or login/OTP codes.
* Can also be used to provide product updates, such as new features or bug fixes.

### Promotional notifications

* Centered on promoting products, services, or events.
* Can be used to generate leads, increase sales, or drive engagement.

### Key Differences

* Product notifications are triggered by user activity, while promotional notifications are sent at the discretion of the marketer.
* Product notifications are typically more transactional in nature, while promotional notifications are more marketing-oriented.
* Product notifications are often sent to all subscribers, while promotional notifications can be targeted to specific audiences.

## Notification channels

Novu supports all major notification channels, and integrates with multiple delivery providers for each one. Each channel can use the same source notification content, as desired.

* [Email](/channels-and-providers/email/overview)
* [Push](/channels-and-providers/push/overview)
* [SMS](/channels-and-providers/sms/overview)
* [Chat](/channels-and-providers/chat/overview)
* [In-App](/channels-and-providers/in-app/introduction)

## Who is Novu for?

How you use and get started with Novu depends on your role. While it’s implemented initially by engineering and development teams, Novu unifies everyone in an organization that authors, creates, sends, manages and measures results from notifications being sent to end users. Novu empowers engineers to deliver notification platforms for product teams.

### Novu for developers and engineering teams

Novu empowers developers and engineering teams to quickly deliver a fully extensible notifications platform for product teams to create captivating notification experiences.

We provide the following proven stack for developers to simply integrate into their products:

* **[Unified API](/api-reference/overview)  & [SDK clients](/sdks/introduction)** for managing all channels and platforms across multiple programming languages.
* **[Prebuilt, customisable UI components](/notification-center/introduction#ui-libraries)** for in-app user notification feeds and preference experiences.
* **[Integration with multiple delivery providers](/channels-and-providers/introduction)**, allowing you to continue using your preferred vendors with Novu.
* **[Scalable, reliable Novu Cloud SaaS infrastructure](https://web.novu.co)** developed from scratch to meet the demands of high-volume notification delivery and storage (think hundreds of millions of notifications).
* **[Observability](/activity-feed/introduction)** for delving into the lifecycle of notification’s success or failure.  Eliminate guesswork of how, when, and why a user receives a notification.
* **Comprehensive documentation**, implementation guides, recipes and illustrative examples.
* **Compliance and security** for safely managing your data.
* **Open source** based provides trust, generates significant community input, and enables you to deploy and self-host a Novu Project instance into any environment of your choosing.

Notification content can be written in a variety of common content tooling, including [React](/framework/integrations/react-email), [Vue-email](/framework/integrations/vue-email), [MJML](/guides/framework-guides/framework-mjml), and more. Content can also be customized and hydrated using any datasource.

### Novu for product teams

We are well aware of the friction that often exists between engineering and product teams, and have built features that allow product teams to customize notification experiences easily and safely—without risking disrupting or breaking important integrations and logic.

Product teams can craft beautiful notification content and campaigns in any content framework of their choice.

* They can modify and manage notification UIs that engineers have built via Novu workflows.
* They gain valuable insights into user engagement with notifications via logs and analytics.
* They can use their preferred notification content editors.
* They can focus on crafting impactful notification content while engineers

### Novu for end users

When implemented, most end users will not be aware that it’s Novu behind the scenes, other than that they now receive notifications where and when they expect them.

The [Novu Notification Center](/notification-center/introduction) is an embeddable component that when included in your app, enables users to view and set their own notification preferences, including channel, preferred language, and more.

Novu ensures fast delivery and beautiful notification experiences for end users regardless of the channels involved.

With Novu, your app users receive instant notifications via **email**, **in-app alerts**, **SMS**, **push notifications**, and **chat**.

## Use Cases

Novu is heavily customizable, and can tackle nearly any notification requirement, no matter how simple or complex. These are some of the more common use cases:

* **Manage multiple notification providers:** Novu empowers you to manage all your notification delivery providers across email, SMS, push and chat in one place. Developers can add new notification providers across different channels without changing the app codebase.
* **Centralize legacy notification systems:** Reduce notification complexity, unify management and visibility into one platform.
* **Centralized debugging of notifications across multiple channels**: Novu allows you understand and debug notifications sent across different channels in one place.
* **In-app Notification Center:** Novu provides a real-time embedded notification center widget that can simply be dropped into any web application to enable end users to manage their own notification preferences.
* **Notification personalization:** Novu provides a user preferences feature that gives your end users a say in how they want to receive notifications.
* **Notification content management:** Novu provides the ability to integrate any content framework and tool of your choice to manage notification content across teams.
* **Send notifications in users language of choice**: Novu allows you to send notifications in preferred users language. App and notification internalization increases users engagement and retention in your product.
* **Reduce notification alert fatigue**: Novu prevents notification fatigue by providing the ability to batch multiple notifications and send as one to subscribers (end users). Leverage Novu in digesting multiple notification events.


# Sign Up on Novu Cloud
Source: https://v0.x-docs.novu.co/getting-started/novu-sign-up

Sign up to our managed service

## Introduction

Novu’s aim is to simplify sending notifications across platforms. As such, we provide simple components, APIs, SDKs and more to help you manage product communication across channels.

This comprehensive guide will help you kickstart your journey with Novu and get your hands dirty!

Everything you need to get up and running successfully can be found here. Let’s begin!

## Signing up to Novu Cloud

Novu Cloud is our managed service that lets you oversee all aspects of your product communication from a user-friendly web dashboard. With Novu Cloud, you can handle various communication channels, create and manage workflows, switch organizations and monitor your activity, ensuring that you get comprehensive control over your product communication and that your message reaches your customers effectively.

To be able to do this and a lot more, you need to sign up for Novu Cloud:

1. Head to [Novu Cloud](https://web.novu.co/auth/signup?utm_campaign=docs-gs-signup). You’ll see this:

<Frame>
  <img />
</Frame>

2. To sign up, you can either use your email and password or sign up using Github. Choose what you wish to proceed with, read the terms and conditions, check its checkbox and click the sign-up button.

<Frame>
  <img />
</Frame>

3. You’ll then be asked to create an Organization. Organizations help you segregate communication between your different products. You can learn more about organisations here. Simply enter your organization name and click on the ‘create’ button:

<Frame>
  <img />
</Frame>

4. On creating an organization, you’ll be greeted with the get started page:

<Frame>
  <img />
</Frame>

This gives you access to a lot of options:

<Frame>
  <img />
</Frame>

1. Accessing support
2. Managing your account
3. Configuring different channels
4. Navigating to any other sections of the dashboard

From here, you can navigate to any part of the web dashboard. Let’s now see Novu in action!


# Send Your First Notification
Source: https://v0.x-docs.novu.co/getting-started/send-your-first-notification

Learn how to send your first notification via the Novu Cloud dashboard.

Sending the first notification is fairly simple, and can be done from within the web dashboard. To send your first notification, follow these steps:

## Workflow for Email notifications

1. Navigate to the workflow section from the left sidebar:

   <Frame>
     <img />
   </Frame>

2. Click on the `Blank Workflow` button to create an empty workflow:

   <Frame>
     <img />
   </Frame>

3. You are now in the workflow editor. Here you can add steps to your workflow. We’ll just drag the email node from the right sidebar to our workflow as illustrated below:

   <Frame>
     <img />
   </Frame>

4. Now, simply click on the email node, and add the subject and the notification
   text in the email node editor:

   <Frame>
     <img />
   </Frame>

5. Now, update the workflow and save it as shown in the image below:

   <Frame>
     <img />
   </Frame>

6. Now, to execute this workflow, click on the `get snippet` button from the workflow editor:

   <Frame>
     <img />
   </Frame>

7. From the `run a test` tab, you can change the email to which you want the notification. Once you’ve done that, simply click on the `Run Trigger` button on the bottom right:

   <Frame>
     <img />
   </Frame>

8. Now, go to the inbox and you’ll see the email notification there. Don’t forget also to check spam as it may sometimes land in there:

   <Frame>
     <img />
   </Frame>

9. This gif below captures the entire process:

   <Frame>
     <img />
   </Frame>

## Workflow for In-App notifications

Creating workflows for sending in-app notifications is pretty straightforward. Just follow the following steps and you'll be good to go:

1. Head to `workflows` on the [Novu web dashboard](https://web.novu.co/workflows?utm_campaign=docs-gs-sendfirstnotification).

   <Frame>
     <img />
   </Frame>

2. Click on the Blank Workflow button to create a workflow from scratch.

   <Frame>
     <img />
   </Frame>

<Note>
  If you want to avoid creating a workflow from scratch, then instead of
  choosing `Blank Workflow`, select `All Templates` and you'll find a bunch of
  workflow templates that you can customize and use:

  <Frame>
    <img />
  </Frame>

  <br />

  <Frame>
    <img />
  </Frame>
</Note>

3. You'll now end up in the workflow editor. Workflow editor, as the name suggests, is the place from where you can edit workflows. You can select which [channels](/channels-and-providers/introduction#channels) you want to send notifications in, add [digest](/guides/add-digest-to-inapp-notifications) to your in-app notifications and more.

   <Frame>
     <img />
   </Frame>

4. For your use case here, we'll simply add an `in-app` node to our workflow.

   <Note>
     Don't forget to rename your workflow to an appropriate name.

     <Frame>
       <img />
     </Frame>
   </Note>

5. Now, the `in-app` node has a lot of options for you to configure:

   <Frame>
     <img />
   </Frame>

* **Preview**: This shows you a glimpse of what each notification item will look like in the Notification Center UI.
* **Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.

6. In this editor, you need to plug in the variable that your backend is expecting in the payload:

   <Frame>
     <img />
   </Frame>

7. You can even use [handlebars](/content-creation-design/handlebars-helpers) to further customise this.

8. Once you're done configuring it, simply click the `update` button on the top right corner.

   <Frame>
     <img />
   </Frame>

9. Now, simply click on the `Get Snippet` button to get the trigger code snippet.

   <Frame>
     <img />
   </Frame>

10. You'll get the code that you need to plug into your backend to be executed whenever an event fires.

    <Frame>
      <img />
    </Frame>

    <br />

    <Warning>
      Don't forget to use your actual `API_KEY` and `subscriberId`.
    </Warning>

That's it, you've successfully built a workflow for sending in-app notifications!

## Workflow for SMS notifications

SMS workflows are not very different from [email](/getting-started/send-your-first-notification#workflow-for-email-notifications) and [in-app](localhost:3001/getting-started/send-your-first-notification#workflow-for-in-app-notifications) workflows we've created above. Let's take a look at it:

1. Head to `Workflows` on the [Novu web dashboard.](https://web.novu.co/workflows?utm_campaign=docs-gs-sendfirstnotification)

   <Frame>
     <img />
   </Frame>

2. Click on the `Blank Workflow` button to create a workflow from scratch.

   <Frame>
     <img />
   </Frame>

<Note>
  If you want to avoid creating a workflow from scratch, then instead of
  choosing `Blank Workflow`, select `All Templates` and you'll find a bunch of
  workflow templates that you can customize and use:

  <Frame>
    <img />
  </Frame>

  <br />

  <Frame>
    <img />
  </Frame>
</Note>

3. You'll now end up in the workflow editor. Workflow editor, as the name suggests, is the place from where you can edit workflows. You can select which [channels](/channels-and-providers/introduction#channels) you want to send notifications in, add [digest](/guides/add-digest-to-inapp-notifications) to your in-app notifications and more.

   <Frame>
     <img />
   </Frame>

4. Since we're creating a workflow for SMS notifications, we'll drag the `SMS` step to our workflow, as shown in this picture below:

   <Frame>
     <img />
   </Frame>

5. If you hover over the SMS node, you will get a message saying 'Required - SMS content\`. Click on the SMS node and add a message to it. This is what will be sent as a notification in the SMS.

   <Frame>
     <img />
   </Frame>

   <br />

   <Note>
     Instead of having static messages, you can have your notifications be
     dynamic by using `handlebars`. Take a look
     [here](/content-creation-design/handlebars-helpers) for more. If your
     backend is expecting data in the payload, plug that variable here in double
     braces.
   </Note>

6. Once you’re done configuring it, simply click the update button on the top right corner.

   <Frame>
     <img />
   </Frame>

7. Now, simply click on the Get Snippet button to get the trigger code snippet.

   <Frame>
     <img />
   </Frame>

8. You’ll get the code that you need to plug into your backend to be executed whenever an event fires.

   <Frame>
     <img />
   </Frame>

   <Warning>Don’t forget to use your actual API\_KEY and subscriberId.</Warning>
   That’s it, you’ve successfully built a workflow for sending in-app
   notifications!

## Workflow for Chat notifications

Chat workflows are quite similar to [email](/getting-started/send-your-first-notification#workflow-for-email-notifications), [in-app](localhost:3001/getting-started/send-your-first-notification#workflow-for-in-app-notifications), and [SMS workflows](/getting-started/send-your-first-notification#workflow-for-sms-notifications) workflows we've created above. Let's take a look at it in detail:

1. Head to `Workflows` on the [Novu web dashboard.](https://web.novu.co/workflows?utm_campaign=docs-gs-sendfirstnotification)

   <Frame>
     <img />
   </Frame>

2. Click on the `Blank Workflow` button to create a workflow from scratch.

   <Frame>
     <img />
   </Frame>

   <br />

   <Note>
     If you want to avoid creating a workflow from scratch, then instead of
     choosing `Blank Workflow`, select `All Templates` and you'll find a bunch
     of workflow templates that you can customize and use:

     <Frame>
       <img />
     </Frame>

     <br />

     <Frame>
       <img />
     </Frame>
   </Note>

3. You'll now end up in the workflow editor. Workflow editor, as the name suggests, is the place from where you can edit workflows. You can select which [channels](/channels-and-providers/introduction#channels) you want to send notifications in, add [digest](/guides/add-digest-to-inapp-notifications) to your in-app notifications and more.

   <Frame>
     <img />
   </Frame>

4. Just add this `Chat` node to the workflow.

   <Frame>
     <img />
   </Frame>

5. In the `Chat` node, you can enter the notification message. This is what will get sent to the [subscriber](/subscribers/subscribers) as a notification. If you're sending dynamic messages, use the variable that is expected in your payload in double braces here. Using [handlebars](/content-creation-design/handlebars-helpers), you can further extend this functionality.

   <Frame>
     <img />
   </Frame>

6. Once you’re done configuring it, simply click the update button on the top right corner.

   <Frame>
     <img />
   </Frame>

7. Now, simply click on the Get Snippet button to get the trigger code snippet.

   <Frame>
     <img />
   </Frame>

8. You’ll get the code that you need to plug into your backend to be executed whenever an event fires.

   <Frame>
     <img />
   </Frame>

   <Warning>Don’t forget to use your actual API\_KEY and subscriberId.</Warning>
   That’s it, you’ve successfully built a workflow for sending chat notifications!

Don't forget to check out our [guides](/guides/add-digest-to-inapp-notifications) and [demo apps](/demos/introduction) for more information on specific features.


# Angular Component
Source: https://v0.x-docs.novu.co/notification-center/client/angular



The `@novu/notification-center-angular` package provides an Angular component wrapper over the Notification Center Web Component that you can use to integrate the notification center into your Angular application.

## Installation

<Tip>Novu supports Angular version 15 and higher.</Tip>

<CodeGroup>
  ```bash pnpm theme={null}
  pnpm i @novu/notification-center-angular
  ```

  ```bash npm theme={null}
  npm i @novu/notification-center-angular
  ```

  ```bash yarn theme={null}
  yarn add @novu/notification-center-angular
  ```
</CodeGroup>

## Example usage

Module:

```tsx theme={null}
import { NotificationCenterModule } from '@novu/notification-center-angular';

@NgModule({
  imports: [..., NotificationCenterModule],
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
})
export class TheModule {}
```

Component:

```tsx theme={null}
import { Component } from "@angular/core";
import { environment } from "../environments/environment";

@Component({
  selector: "my-component",
  templateUrl: "./component.html",
})
export class AppComponent {
  subscriberId = environment.subscriberId;
  applicationIdentifier = environment.applicationIdentifier;

  sessionLoaded = (data: unknown) => {
    console.log("loaded", { data });
  };
}
```

Component HTML template:

```html theme={null}
<notification-center-component
  [subscriberId]="subscriberId"
  [applicationIdentifier]="applicationIdentifier"
  [sessionLoaded]="sessionLoaded"
></notification-center-component>
```

## Props

The `notification-center-component` accepts the same set of props as the [web component](/notification-center/client/web-component).

<Tip>
  You may need to add `"allowSyntheticDefaultImports": true` in tsconfig.json for the web component's React imports to work correctly.
</Tip>

## Example

* [Angular Notification Center Example Repo](https://github.com/novuhq/examples/tree/main/novu-angular-notification-center)
* [Example Source Code 🔗](https://github.com/novuhq/examples/tree/main/novu-angular-notification-center)


# Get Started
Source: https://v0.x-docs.novu.co/notification-center/client/headless/get-started



The headless version of Novu's notification library package provides users with a lightweight solution for integrating notification functionality into their web applications. With just the essential API methods, users can easily incorporate our notification system into any framework or vanilla JavaScript project, without being constrained by our default UI or dependencies.

## Installation

```bash theme={null}
npm install @novu/headless
```

Then, in your project import the headless service:

```
import { HeadlessService, FetchResult, ISession } from '@novu/headless';
```

## Initialize the session

To use the headless service and its features, you'll need to first initialize the session:

```tsx theme={null}
const headlessService = new HeadlessService({
  applicationIdentifier: "APPLICATION_IDENTIFIER",
  subscriberId: "SUBSCRIBER_ID",
});

headlessService.initializeSession({
  listener: (res: FetchResult<ISession>) => {
    console.log(res);
  },
  onSuccess: (session: ISession) => {
    console.log(session);
  },
  onError: (error) => {
    console.error(error);
  },
});
```

## Use your own backend and socket url

By default, Novu's hosted services of API and socket are used. Should you want, you could override them and configure your own.

```tsx theme={null}
const headlessService = new HeadlessService({
  applicationIdentifier: "APPLICATION_IDENTIFIER",
  subscriberId: "SUBSCRIBER_ID",
  backendUrl: "YOUR_BACKEND_URL",
  socketUrl: "YOUR_SOCKET_URL",
});

headlessService.initializeSession({
  listener: (session) => {
    console.log(session);
  },
  onSuccess: (session) => {
    console.log(session);
  },
  onError: (error) => {
    console.error(error);
  },
});
```

## Fetch Notifications

```jsx theme={null}
import { IPaginatedResponse, IMessage } from "@novu/headless";

headlessService.fetchNotifications({
  listener: ({ data, error, isError, isFetching, isLoading, status }) => {
    console.log({ data, error, isError, isFetching, isLoading, status });
  },
  onSuccess: (response: IPaginatedResponse<IMessage>) => {
    console.log(
      response.data,
      response.page,
      response.totalCount,
      response.pageSize
    );
  },
  page: 1, // page number to be fetched
});
```

<Note>fetchNotifications and other methods of the headless service should be used after initializing the session using headlessService.initializeSession</Note>

## HMAC Encryption

To use the Hash-Based Message Authentication Codes pass the HMAC code to the headless service:

```typescript theme={null}
const headlessService = new HeadlessService({
  applicationIdentifier: "APP_ID_FROM_ADMIN_PANEL",
  subscriberId: "USER_ID",
  subscriberHash: "HASHED_SUBSCRIBER_ID",
});
```

## Realtime Sockets

Novu headless library provides listenUnseenCountChange API to listen to real-time socket changes and get updates about new notifications added to the user's feed.

### unseen count changes

```typescript theme={null}
headlessService.listenUnseenCountChange({
  // this will run every time there's a change in the `unseen_count` in real-time
  listener: (unseenCount: number) => {
    console.log(unseenCount);
  },
});
```

### unread count changes

```typescript theme={null}
headlessService.listenUnreadCountChange({
  // this will run every time there's a change in the `unread_count` in real-time
  listener: (unreadCount: number) => {
    console.log(unreadCount);
  },
});
```

<Tip>
  If you're ready to start using the Headless Notification Center, check out our [guide!](/guides/headless-notification-center-guide)
</Tip>

[Explore Implementation of the Headless Library in an App](https://github.com/novuhq/novu-headless-demo-app)

[Headless Demo](https://headlessdemo.vercel.app)

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="How to use headless library for multiple users? ">
    We have `headless.initializeSession` method to generate token and initialize the session. If user log out and new user login, then calling again this method with second user subscriberId will generate new token and new session.
  </Accordion>

  <Accordion title="Can headless be used with mobile based platforms like flutter and react native?">
    Currently, headless can not be used with react native and flutter. Checkout the progress on mobile platform support on github issue [#4499](https://github.com/novuhq/novu/issues/4499).
  </Accordion>
</AccordionGroup>


# Iframe Embed
Source: https://v0.x-docs.novu.co/notification-center/client/iframe



If you are using a (currently) unsupported client framework, you can use our embedded script. This will generate the notification center inside an iframe

```html theme={null}
<script>
  (function (n, o, t, i, f) {
    n[i] = {};
    var m = ["init", "on"];
    n[i]._c = [];
    m.forEach(
      (me) =>
        (n[i][me] = function () {
          n[i]._c.push([me, arguments]);
        })
    );
    var elt = o.createElement(f);
    elt.type = "text/javascript";
    elt.async = true;
    elt.src = t;
    var before = o.getElementsByTagName(f)[0];
    before.parentNode.insertBefore(elt, before);
  })(
    window,
    document,
    "https://embed.novu.co/embed.umd.min.js",
    "novu",
    "script"
  );

  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
    },
    {
      subscriberId: "SUBSCRIBER_ID",
      email: "SUBSCRIBER_EMAIL",
      first_name: "SUBSCRIBER_FIRST_NAME",
      last_name: "SUBSCRIBER_LAST_NAME",
    }
  );
</script>
```

Replace the selectors for the bell icon and the unseen badge within your code. Let's take a look at this example code:

```html theme={null}
<nav>
  <div id="notification-bell">
    <i class="fa fa-bell"></i>
    <span id="unseen-badge"></span>
  </div>
</nav>
```

## Customizing the dropdown position

Optionally, the embedded init script receives a position object, you can use this to specify the `left` and `top` position of the notification center.

```html theme={null}
<script>
  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      position: {
        top: "50px",
        left: "100px",
      },
    },
    {
      ...subscriberProps,
    }
  );
</script>
```

## Customizing the theme

The notification center component can be customized by passing a `theme` to the init script. Checkout all possible theme [properties](/notification-center/client/react/api-reference).

```html theme={null}
<script>
  const customTheme = {
    light: {
      layout: {
        background: "red",
      },
    },
  };

  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      theme: customTheme,
    },
    {
      ...subscriberProps,
    }
  );
</script>
```

## Customizing the UI language

The language of the UI can be customized by passing an `i18n` component to the init script. More information on all possible [properties](/notification-center/client/react/customization#customize-the-ui-language).

```html theme={null}
<script>
  const customLanguage = {
    lang: "en",
    translations: {
      notifications: "My custom notifications!",
    },
  };

  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      i18n: customLanguage,
    },
    {
      ...subscriberProps,
    }
  );
</script>
```

## Handle User Interaction

In order to handle certain events like the user clicking on the notification, or clicking on an action button inside a notification, you can listen for these events and handle them accordingly.

```html theme={null}
<script>
  novu.on("notification_click", (notification) => {
    // do custom logic here
  });

  novu.on("action_click", ({ templateIdentifier, type, notification }) => {
    // do custom logic here
  });
</script>
```

## Enabling HMAC Encryption

In order to enable Hash-Based Message Authentication Codes, you need to visit the admin panel's In-App settings page and enable HMAC encryption for your environment.

The next step would be to generate an HMAC encrypted subscriberId on your backend:

```javascript theme={null}
import { createHmac } from "crypto";

const hmacHash = createHmac("sha256", process.env.NOVU_API_KEY)
  .update(subscriberId)
  .digest("hex");
```

Then pass the created HMAC to your client side application forward it to the embed initialization script:

```html theme={null}
<script>
  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      position: {
        top: "50px",
        left: "100px",
      },
    },
    {
      subscriberId: "SUBSCRIBER_ID_PLAIN_VALUE",
      subscriberHash: "SUBSCRIBER_ID_HASH_VALUE",
    }
  );
</script>
```

## Example

[![Edit novu-iframe-nc](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/novu-iframe-nc-t9ns9d?fontsize=14\&hidenavigation=1\&theme=dark)

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="The notification bell is not showing in the iframe.">
    We use font awesome bell icon. Make sure you have added the font awesome CSS cdn link in the head tag.

    ```html theme={null}
    <link
      rel="stylesheet"
      href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css"
      integrity="sha512-iecdLmaskl7CVkqkXNQ/ZH/XLlvWZOJyj7Yy7tcenmpD1ypASozpmT/E0iPtmFIB46ZmdtAc9eNBvH0H/ZpiBw=="
      crossorigin="anonymous"
      referrerpolicy="no-referrer"
    />
    ```
  </Accordion>
</AccordionGroup>


# API Reference
Source: https://v0.x-docs.novu.co/notification-center/client/react/api-reference



## React Notification Center API Reference

This page contains complete documentation about the React Notification Center package. You can find here the list of all the components, hooks, and props that you can use.

## Components

Components are the building blocks of the React Notification Center package. They are used to build the UI of the notification center.

## NovuProvider

The NovuProvider is the root component of the React Notification Center package. It is used to wrap the components code and provide the notifications feed context to all its children.
It's responsible for establishing the notification center session, managing the web socket connection, and fetching the notifications feed.

| Prop                    | Type                                                                           | Description                                                                                                                                                                                                                                                                                                                                                                     |
| ----------------------- | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| backendUrl              | string (optional)                                                              | The custom backend URL, your own deployed instance of the API. The default is [https://api.novu.co.app/](https://api.novu.co.app/).                                                                                                                                                                                                                                             |
| socketUrl               | string (optional)                                                              | The custom socket URL, your own deployed instance of the WS app. The default is [https://ws.novu.co/](https://ws.novu.co/).                                                                                                                                                                                                                                                     |
| applicationIdentifier   | string                                                                         | The app id is taken from the Novu Settings -> API Keys tab.                                                                                                                                                                                                                                                                                                                     |
| subscriberId            | string                                                                         | The unique user id from your system.                                                                                                                                                                                                                                                                                                                                            |
| subscriberHash          | string (optional)                                                              | The HMAC encrypted subscriberId. Read about [hmac encryption](/notification-center/client/react/get-started#hmac-encryption)                                                                                                                                                                                                                                                    |
| stores                  | [IStore](#store-interface) (optional)                                          | The connection object between feed and notification center tab.                                                                                                                                                                                                                                                                                                                 |
| i18n                    | [ITranslationEntry \| ITranslationContent](#i18nlanguage-interface) (optional) | The prop allows to configure the UI language.                                                                                                                                                                                                                                                                                                                                   |
| styles                  | [NotificationCenterStyles](#styles-interface) (optional)                       | The prop allowing to style the notification center. It's based on the CSSInterpolation object from the [@emotion/css](https://emotion.sh/docs/@emotion/css#object-styles) package.                                                                                                                                                                                              |
| initialFetchingStrategy | [IFetchingStrategy](#fetching-strategy-interface) (optional)                   | The fetching strategy. By default notifications feed and user preferences are not fetched until the notification center is opened. You might need to tweak this configuration when building a custom UI and if you need to fetch notifications right away. Also it's possible to change it when some action happens using the useNovuContext hook and setFetchingStrategy prop. |
| children                | object                                                                         | The ReactNode object type, the "consumer" of the NovuProvider context.                                                                                                                                                                                                                                                                                                          |
| onLoad                  | [function](#props-interface) (optional)                                        | The function that is called with an organization object after the notification center session is initialized.                                                                                                                                                                                                                                                                   |

### Props interface

```typescript theme={null}
interface INovuProviderProps {
  backendUrl?: string;
  socketUrl?: string;
  applicationIdentifier: string;
  subscriberId?: string;
  subscriberHash?: string;
  stores?: IStore[];
  i18n?: I18NLanguage | ITranslationEntry;
  styles?: INotificationCenterStyles;
  initialFetchingStrategy?: Partial<IFetchingStrategy>;
  children: React.ReactNode;
  onLoad?: (data: { organization: IOrganizationEntity }) => void;
}
```

### Store interface

```typescript theme={null}
interface IStore {
  storeId: string;
  query?: IStoreQuery;
}

interface IStoreQuery {
  feedIdentifier?: string | string[];
  seen?: boolean;
  read?: boolean;
  limit?: number; 
  payload?: Record<string, unknown>;
}
```

### I18NLanguage interface

```typescript theme={null}
type I18NLanguage = 'en' | 'de' ...;

interface ITranslationContent {
  readonly notifications: string;
  readonly markAllAsRead: string;
  readonly poweredBy: string;
  readonly settings: string;
  readonly removeMessage: string;
  readonly markAsRead: string;
  readonly markAsUnRead: string;
}

interface ITranslationEntry {
  readonly translations: Partial<ITranslationContent>;
  readonly lang: string;
}

```

### Styles interface

```typescript theme={null}
interface NotificationCenterStyles {
  bellButton?: ObjectWithRoot<{
    dot?: CSSFunctionOrObject;
  }>;
  unseenBadge?: CSSFunctionOrObject;
  popover?: {
    arrow?: CSSFunctionOrObject;
    dropdown?: CSSFunctionOrObject;
  };
  loader?: ObjectWithRoot;
  layout?: ObjectWithRoot;
  header?: ObjectWithRoot<{
    title?: CSSFunctionOrObject;
    markAsRead?: CSSFunctionOrObject;
    cog?: CSSFunctionOrObject;
    backButton?: CSSFunctionOrObject;
  }>;
  tabs?: {
    tabsList?: CSSFunctionOrObject;
    tab?: CSSFunctionOrObject;
    tabLabel?: CSSFunctionOrObject;
    tabIcon?: CSSFunctionOrObject;
  };
  accordion?: {
    item?: CSSFunctionOrObject;
    content?: CSSFunctionOrObject;
    control?: CSSFunctionOrObject;
    chevron?: CSSFunctionOrObject;
  };
  switch?: ObjectWithRoot<{
    input?: CSSFunctionOrObject;
    track?: CSSFunctionOrObject;
    thumb?: CSSFunctionOrObject;
  }>;
  footer?: ObjectWithRoot<{
    title?: CSSFunctionOrObject;
  }>;
  notifications?: ObjectWithRoot<{
    listItem?: {
      read?: CSSFunctionOrObject;
      unread?: CSSFunctionOrObject;
      layout?: CSSFunctionOrObject;
      contentLayout?: CSSFunctionOrObject;
      title?: CSSFunctionOrObject;
      timestamp?: CSSFunctionOrObject;
      dotsButton?: CSSFunctionOrObject;
      buttons?: ObjectWithRoot<{
        primary?: CSSFunctionOrObject;
        secondary?: CSSFunctionOrObject;
      }>;
    };
  }>;
  actionsMenu?: {
    arrow?: CSSFunctionOrObject;
    dropdown?: CSSFunctionOrObject;
    item?: CSSFunctionOrObject;
  };
  preferences?: ObjectWithRoot<{
    item?: {
      title?: CSSFunctionOrObject;
      channels?: CSSFunctionOrObject;
      divider?: CSSFunctionOrObject;
      content?: {
        icon?: CSSFunctionOrObject;
        channelLabel?: CSSFunctionOrObject;
        success?: CSSFunctionOrObject;
      };
    };
  }>;
}

type CSSFunctionInterpolation = (args: {
  theme: INovuTheme;
  common: ICommonTheme;
  colorScheme: ColorScheme;
}) => CSSInterpolation;

type CSSFunctionOrObject = CSSFunctionInterpolation | CSSInterpolation;

type ObjectWithRoot<T = {}> = T & {
  root: CSSFunctionOrObject;
};
```

<Accordion title="How to use the Styles Interface?">
  To use the Styles Interface, you need to identify the property you need to modify to achieve your desired look and pass it as an object in the `styles` prop.

  <br />

  As listed in the [Styles Interface](/notification-center/client/react/api-reference#styles-interface), the notification center is made up of a number of components which can each be individually customized.

  <br />

  You can also check out our [docs on customizing styles](https://docs.novu.co/notification-center/client/react/api-reference#styles-interface) to see how to define styles for various components that make up the notification center.

  <br />

  #### Let's take an example to see this in action:

  By default, this is how the notification center looks:

  <Frame>
    <img />
  </Frame>

  Say, you wanted the text color to match the accent color. You just need to go over to the [docs on customizing styles](https://docs.novu.co/notification-center/client/react/api-reference#styles-interface) and find out which property needs to be modified. In our case, we need to change the `color` property as evident here:

  <Frame>
    <img />
  </Frame>

  Now, that we know which property needs to change, all we need to do is pass an object to the `styles` prop while maintaining the nesting of object keys:

  ```javascript theme={null}
  <div className='bell'>
      <NovuProvider
          subscriberId={process.env.REACT_APP_SUB_ID}
          applicationIdentifier={process.env.REACT_APP_APP_ID}

          styles={{ notifications: { listItem: { layout: { color: '#E3554D' } } } }}

      >
          <PopoverNotificationCenter >
              {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
          </PopoverNotificationCenter>
      </NovuProvider>
  </div >
  ```

  This gives us the desired result:

  <Frame>
    <img />
  </Frame>

  <Note>Please have a look at our [docs on customizing styles](https://docs.novu.co/notification-center/client/react/api-reference#styles-interface) to see how to define styles for various components of the notification center.</Note>
</Accordion>

### Fetching strategy interface

```typescript theme={null}
interface IFetchingStrategy {
  fetchUnseenCount: boolean;
  fetchOrganization: boolean;
  fetchNotifications: boolean;
  fetchUserPreferences: boolean;
}
```

## PopoverNotificationCenter

The floating popover component that appears when clicking on the [NotificationBell](#notificationbell) button. It renders the [NotificationCenter](#notificationcenter) component inside its content.

| Prop                       | Type                                            | Description                                                                                                                                                                                                  |
| -------------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| position                   | string (optional)                               | Position of the popover relative to the bell icon. It is based on the [Mantine Popover](https://mantine.dev/core/popover/?t=props). The default is set to `bottom-end`.                                      |
| offset                     | number (optional)                               | Gap between the Bell icon and Popover in px.                                                                                                                                                                 |
| colorScheme                | string                                          | The UI light or dark mode.                                                                                                                                                                                   |
| theme                      | [INovuTheme](#the-theme-interface) (optional)   | The theme object allowing you to override light and dark colors of the UI components. Deprecated for styling, please use the [styles](#styles-interface) prop on the NovuProvider.                           |
| tabs                       | [ITab](#the-tab-interface)(optional)            | Allows to define separate UI tabs for the notifications feed. The array of connection objects between the feed tab and [stores](#store-interface) (that you define on the NovuProvider) and feed identifier. |
| listItem                   | [ListItem](#the-list-item-interface) (optional) | The render function allowing you to define the custom element for the notification list item.                                                                                                                |
| showUserPreferences        | boolean (optional)                              | The flag that enables to show/hide the user preferences. By default it is enabled.                                                                                                                           |
| allowedNotificationActions | boolean (optional)                              | The flag that enables to show/hide the dots menu for actions performed on a notification. By default it is enabled.                                                                                          |
| onUrlChange                | function (optional)                             | The function that is called when the notification item has a CTA of type redirect and is clicked.                                                                                                            |
| onNotificationClick        | function (optional)                             | The function that is called when the notification item is clicked.                                                                                                                                           |
| onUnseenCountChanged       | function (optional)                             | The function that is called when the unseen notifications count changed.                                                                                                                                     |
| children                   | function                                        | The render function that allows you to define the custom bell button. It's called with an argument that has unseenCount prop the number of unseen notifications.                                             |
| header                     | function (optional)                             | The render function that allows you to define the custom header component.                                                                                                                                   |
| footer                     | function (optional)                             | The render function that allows you to define the custom footer component.                                                                                                                                   |
| emptyState                 | JSX.Element (optional)                          | The render function that allows you to define the custom component for the empty notifications list state.                                                                                                   |
| onActionClick              | function (optional)                             | The callback function triggered when the notification button is clicked.                                                                                                                                     |
| actionsResultBlock         | function (optional)                             | The render function that allows you to define the custom component that will be rendered after the notification button is clicked.                                                                           |
| onTabClick                 | function (optional)                             | The callback function triggered when the notifications feed tab changes.                                                                                                                                     |
| preferenceFilter           | function (optional)                             | The callback function triggered when filtering the subscriber preference.                                                                                                                                    |

### Props interface

```typescript theme={null}
interface IPopoverNotificationCenterProps {
  position?: PopoverProps["position"];
  offset?: number;
  colorScheme: ColorScheme;
  theme?: INovuThemePopoverProvider;
  tabs?: ITab[];
  listItem?: ListItem;
  showUserPreferences?: boolean;
  allowedNotificationActions?: boolean;
  onUrlChange?: (url: string) => void;
  onNotificationClick?: (notification: IMessage) => void;
  onUnseenCountChanged?: (unseenCount: number) => void;
  children: (props: INotificationBellProps) => JSX.Element;
  header?: () => JSX.Element;
  footer?: () => JSX.Element;
  emptyState?: JSX.Element;
  onActionClick?: (
    templateIdentifier: string,
    type: ButtonTypeEnum,
    message: IMessage
  ) => void;
  actionsResultBlock?: (
    templateIdentifier: string,
    messageAction: IMessageAction
  ) => JSX.Element;
  onTabClick?: (tab: ITab) => void;
  preferenceFilter?: (userPreference: IUserPreferenceSettings) => boolean;
}
```

More information about the [IMessage](#the-notification-imessage-model) interface, and the [theme](#the-theme-interface) interface.

### The tab interface

```typescript theme={null}
interface ITab {
  name: string;
  storeId: string;
}
```

### The list item interface

```typescript theme={null}
type ListItem = (
  message: IMessage,
  onActionButtonClick: (actionButtonType: ButtonTypeEnum) => void,
  onNotificationClick: () => void
) => JSX.Element;
```

## NotificationCenter

The component that renders the notifications feed and allows to update the user preferences.

| Prop                       | Type                                            | Description                                                                                                                                                                                                  |
| -------------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| colorScheme                | string                                          | The UI light or dark mode.                                                                                                                                                                                   |
| theme                      | [INovuTheme](#the-theme-interface) (optional)   | The theme object allowing you to override light and dark colors of the UI components. Deprecated for styling, please use the [styles](#styles-interface) prop on the NovuProvider.                           |
| tabs                       | [ITab](#the-tab-interface)(optional)            | Allows to define separate UI tabs for the notifications feed. The array of connection objects between the feed tab and [stores](#store-interface) (that you define on the NovuProvider) and feed identifier. |
| listItem                   | [ListItem](#the-list-item-interface) (optional) | The render function allowing you to define the custom element for the notification list item.                                                                                                                |
| showUserPreferences        | boolean (optional)                              | The flag that enables to show/hide the user preferences. By default it is enabled.                                                                                                                           |
| allowedNotificationActions | boolean (optional)                              | The flag that enables to show/hide the dots menu for actions performed on a notification. By default it is enabled.                                                                                          |
| onUrlChange                | function (optional)                             | The function that is called when the notification item has a CTA of type redirect and is clicked.                                                                                                            |
| onNotificationClick        | function (optional)                             | The function that is called when the notification item is clicked.                                                                                                                                           |
| onUnseenCountChanged       | function (optional)                             | The function that is called when the unseen notifications count changed.                                                                                                                                     |
| header                     | function (optional)                             | The render function that allows you to define the custom header component.                                                                                                                                   |
| footer                     | function (optional)                             | The render function that allows you to define the custom footer component.                                                                                                                                   |
| emptyState                 | JSX.Element (optional)                          | The render function that allows you to define the custom component for the empty notifications list state.                                                                                                   |
| onActionClick              | function (optional)                             | The callback function triggered when the notification button is clicked.                                                                                                                                     |
| actionsResultBlock         | function (optional)                             | The render function that allows you to define the custom component that will be rendered after the notification button is clicked.                                                                           |
| onTabClick                 | function (optional)                             | The callback function triggered when the notifications feed tab changes.                                                                                                                                     |
| preferenceFilter           | function (optional)                             | The callback function triggered when filtering the subscriber preference.                                                                                                                                    |

### Props interface

```typescript theme={null}
interface INotificationCenterProps {
  colorScheme: ColorScheme;
  theme?: INovuThemeProvider;
  tabs?: ITab[];
  listItem?: ListItem;
  showUserPreferences?: boolean;
  allowedNotificationActions?: boolean;
  onUrlChange?: (url: string) => void;
  onNotificationClick?: (notification: IMessage) => void;
  onUnseenCountChanged?: (unseenCount: number) => void;
  header?: () => JSX.Element;
  footer?: () => JSX.Element;
  emptyState?: JSX.Element;
  onActionClick?: (
    templateIdentifier: string,
    type: ButtonTypeEnum,
    message: IMessage
  ) => void;
  actionsResultBlock?: (
    templateIdentifier: string,
    messageAction: IMessageAction
  ) => JSX.Element;
  onTabClick?: (tab: ITab) => void;
  preferenceFilter?: (userPreference: IUserPreferenceSettings) => boolean;
}
```

## NotificationBell

The component that renders the notification bell with the unseen notifications count.

| Prop                       | Type                        | Description                                                  |
| -------------------------- | --------------------------- | ------------------------------------------------------------ |
| unseenCount                | number (optional)           | The number of unseen notifications.                          |
| unseenBadgeColor           | string or object (optional) | The unseen notifications count badge color.                  |
| unseenBadgeBackgroundColor | string (optional)           | The background color of the notification unseen count badge. |
| colorScheme                | string (optional)           | The UI light or dark mode.                                   |

### Props interface

```typescript theme={null}
interface INotificationBellProps {
  unseenCount?: number;
  unseenBadgeColor?: string | ISvgStopColor;
  unseenBadgeBackgroundColor?: string;
  colorScheme?: ColorScheme;
}

interface ISvgStopColor {
  stopColor?: string;
  stopColorOffset?: string;
}
```

## Hooks

### useNotifications

This hook that allows you to get the notifications feed data and unseen notifications count. The notifications are fetched only when the `fetchingStrategy.fetchNotifications` is set to true interface, check the `initialFetchingStrategy` prop on the [NovuProvider](#novuprovider) component.

```typescript theme={null}
const result = useNotifications();
```

`useNotifications` hook return interface

```typescript theme={null}
interface INotificationsContext {
  storeId: string;
  storeQuery: IStoreQuery;
  stores: IStore[];
  unseenCount: number;
  notifications: IMessage[];
  hasNextPage: boolean;
  isLoading: boolean;
  isFetching: boolean;
  isFetchingNextPage: boolean;
  setStore: (storeId?: string) => void;
  fetchNextPage: () => void;
  refetch: () => void;
  markNotificationAsRead: (messageId: string) => void;
  markNotificationAsUnRead: (messageId: string) => void;
  markNotificationAsSeen: (messageId: string) => void;
  markFetchedNotificationsAsRead: () => void;
  markFetchedNotificationsAsSeen: () => void;
  markAllNotificationsAsRead: () => void;
  markAllNotificationsAsSeen: () => void;
  removeMessage: (messageId: string) => void;
  removeAllMessages: (feedId?: string) => void;
}
```

Description of the `useNotifications` hook return interface properties

| Prop                           | Type                                             | Description                                                                                                           |
| ------------------------------ | ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| storeId                        | string                                           | active `storeId`                                                                                                      |
| stores                         | [IStore\[\]](#store-interface)                   | array of [IStore](#store-interface) passed to the [NovuProvider](#novuprovider).                                      |
| unseenCount                    | number                                           | unseen notifications (messages) count.                                                                                |
| notifications                  | [IMessage\[\]](#the-notification-imessage-model) | The feed notifications array.                                                                                         |
| hasNextPage                    | boolean                                          | flag indicating if the next notifications page to fetch is available.                                                 |
| isLoading                      | boolean                                          | flag indicating if the initial notifications fetch request is on the fly.                                             |
| isFetching                     | boolean                                          | flag indicating if the notifications are fetching including initial fetch.                                            |
| isFetchingNextPage             | boolean                                          | flag indicating if the next notifications page request in on the fly.                                                 |
| setStore                       | function                                         | function used to change the current notifications [IStore](#store-interface)                                          |
| fetchNextPage                  | function                                         | function that fires the fetch request for the next notifications page.                                                |
| refetch                        | function                                         | function used to refetch all the notifications, when multiple page requests were made it will refetch all of them.    |
| markNotificationAsRead         | function                                         | function takes the notification (message) `messageId` as an argument and marks that notification (message) as read.   |
| markNotificationAsUnRead       | function                                         | function takes the notification (message) `messageId` as an argument and marks that notification (message) as unread. |
| markNotificationAsSeen         | function                                         | function takes the notification (message) `messageId` as an argument and marks that notification (message) as seen.   |
| markFetchedNotificationsAsRead | function                                         | function marks all the fetched notifications as read.                                                                 |
| markFetchedNotificationsAsSeen | function                                         | function allowing you to mark all the fetched notifications as seen.                                                  |
| markAllNotificationsAsRead     | function                                         | function allowing you to mark all notifications as read.                                                              |
| markAllNotificationsAsSeen     | function                                         | function allowing you to mark notifications as seen.                                                                  |
| removeMessage                  | function                                         | function takes the notification (message) `messageId` as an argument and delete a notification.                       |
| removeAllMessages              | function                                         | The function allowing you to delete all notifications or a specific feed's (store's) notifications at once.           |

### useFetchNotifications

`useFetchNotifications` can fetche the notifications for a particular feed. It's a thin version of the `useNotifications` hook and is based on the `useInfiniteQuery` hook from the `react-query` library. Notifications can be filtered using `payload` property. Check all properties of [IStoreQuery](#store-interface) interface. The notifications are fetched only when the `fetchingStrategy.fetchNotifications` is set to true interface, check the `initialFetchingStrategy` prop on the [NovuProvider](#novuprovider) component.

```typescript theme={null}
const query: IStoreQuery = {
  limit: 10,
  payload: {
    key: "value"
  }
};

const onSuccess = (data: IPaginatedResponse<IMessage>) => {};

const onError = (error: Error) => {};

const {
  data: notificationsPages,
  hasNextPage,
  isLoading,
  isFetching,
  isFetchingNextPage,
  fetchNextPage,
  refetch,
} = useFetchNotifications({ query }, { onSuccess, onError });
```

`useFetchNotifications` hook return args

```typescript theme={null}
interface IUseFetchNotificationsArgs {
  onSuccess?: (data: IPaginatedResponse<IMessage>) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useInfiniteQuery hook
}

```

`useFetchNotifications` hook return interface

```typescript theme={null}
interface InfiniteData<TData> {
  pages: TData[];
  pageParams: unknown[];
}

interface IUseUnseenCountResult {
  data: InfiniteData<IPaginatedResponse<IMessage>>;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useInfiniteQuery hook result
}
```

### useUnseenCount

`useUnseenCount` returns the total unseen notifications count. Under the hood it uses the socket connection to get the unseen count updates.

```typescript theme={null}
interface ICountData {
  count: number;
}

const onSuccess = ({ count }: ICountData) => {};

const onError = (error: Error) => {};

const { data, isLoading, isError, error } = useUnseenCount({ onSuccess, onError });
```

`useUnseenCount` hook args interface

```typescript theme={null}
interface IUseUnseenCountArgs {
  onSuccess?: (data: ICountData) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useUnseenCount` hook return interface

```typescript theme={null}
interface IUseUnseenCountResult {
  data?: ICountData;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useSocket

`useSocket` hooks is used to get the reference to socket object.

```typescript theme={null}
const { socket } = useSocket();
```

`useSocket` return interface

```typescript theme={null}
interface ISocket {
  on: (eventName: string, callback: (data: any) => void) => void;
  off: (eventName: string) => void;
}
```

`useSocket` supported events

| Event                  | Description                                              |
| ---------------------- | -------------------------------------------------------- |
| notification\_received | Triggered when a new notification is received            |
| unseen\_count\_changed | Triggered when the count of unseen notifications changes |
| unread\_count\_changed | Triggered when the count of unread notifications changes |

### useNovuContext

`useNovuContext` hook is used to get the reference to the [NovuProvider](#novuprovider) context.

```typescript theme={null}
const result = useNovuContext();
```

`useNovuContext` hook return interface

```typescript theme={null}
interface INovuProviderContext {
  backendUrl?: string;
  subscriberId?: string;
  applicationIdentifier?: string;
  isSessionInitialized: boolean;
  socketUrl?: string;
  subscriberHash: string;
  apiService: ApiService;
  socket?: ISocket;
  fetchingStrategy: IFetchingStrategy;
  setFetchingStrategy: (strategy: Partial<IFetchingStrategy>) => void;
  onLoad: (data: { organization: IOrganizationEntity }) => void;
}
```

### useFeedUnseenCount

`useFeedUnseenCount` hook fetches the unseen count for a particular feed.

```typescript theme={null}
interface ICountData {
  count: number;
}

const query: IStoreQuery = {
  feedIdentifier: "product-updates"
};

const onSuccess = (data: ICountData) => {};

const onError = (error: Error) => {};

const result = useFeedUnseenCount({ query }, { onSuccess, onError });
```

`useFeedUnseenCount` hook args interface

```typescript theme={null}
interface IUseFeedUnseenCountArgs {
  onSuccess?: (data: ICountData) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useFeedUnseenCount` hook return interface

```typescript theme={null}
interface IUseFeedUnseenCountResult {
  data?: ICountData;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useFetchOrganization

`useFetchOrganization` hok fetches the current organization information.

```typescript theme={null}
interface IOrganizationEntity {
  _id: string;
  name: string;
  members: {
    _id: string;
    _userId?: string;
    user?: Pick<IUserEntity, 'firstName' | '_id' | 'lastName' | 'email'>;
    roles: MemberRoleEnum[];
    invite?: IMemberInvite;
    memberStatus: MemberStatusEnum;
  }[];
  branding?: {
    color: string;
    logo: string;
    fontColor: string;
    fontFamily: string;
    contentBackground: string;
    direction: 'ltr' | 'rtl';
  };
}

const onSuccess = (data: IOrganizationEntity) => {};

const onError = (error: Error) => {};

const result = useFetchOrganization({ onSuccess, onError });
```

`useFetchOrganization` hook args interface

```typescript theme={null}
interface IUseFetchOrganizationArgs {
  onSuccess?: (data: IOrganizationEntity) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useFetchOrganization` hook return interface

```typescript theme={null}
interface IUseFetchOrganizationResult {
  data?: IOrganizationEntity;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useFetchUserPreferences

`useFetchUserPreferences` hook fetches the user preferences.

```typescript theme={null}
const onSuccess = (data: IUserPreferenceSettings[]) => {};

const onError = (error: Error) => {};

const result = useFetchUserPreferences({ onSuccess, onError });
```

`useFetchUserPreferences` hook args interface

```typescript theme={null}
interface IUseFetchUserPreferencesArgs {
  onSuccess?: (data: IUserPreferenceSettings[]) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useFetchUserPreferences` hook return interface

```typescript theme={null}
interface IUseFetchUserPreferencesResult {
  data?: IUserPreferenceSettings[];
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useUpdateUserPreferences

`useUpdateUserPreferences` hook is used to update the user preferences.

```typescript theme={null}
interface IPreferenceChannels {
  email?: boolean;
  sms?: boolean;
  in_app?: boolean;
  chat?: boolean;
  push?: boolean;
}

interface IUserPreferenceSettings {
  template: { _id: string; name: string; critical: boolean };
  preference: { enabled: boolean; channels: IPreferenceChannels };
}

const onSuccess = (data: IUserPreferenceSettings) => {};

const onError = (error: Error) => {};

const { updateUserPreferences, isLoading, isError, error } = useUpdateUserPreferences({
  onSuccess,
  onError,
});
```

`useUpdateUserPreferences` hook args interface

```typescript theme={null}
interface IUserPreferencesArgs {
  onSuccess?: (data: IUserPreferenceSettings) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useUpdateUserPreferences` hook return interface

```typescript theme={null}
interface IUpdateUserPreferencesVariables {
  templateId: string; // workflowId of mongodbId type
  channelType: string;
  checked: boolean;
}

interface IUserPreferencesResult {
  updateUserPreferences: (variables: IUpdateUserPreferencesVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useUpdateAction

`useUpdateAction` hook can be used to update the notification action button status.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { updateAction, isLoading, isError, error } = useUpdateAction({ onSuccess, onError });
```

`useUpdateAction` hook args interface

```typescript theme={null}
interface IUseUpdateActionArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useUpdateAction` hook return interface

```typescript theme={null}
interface IUpdateActionVariables {
  messageId: string;
  actionButtonType: ButtonTypeEnum;
  status: MessageActionStatusEnum;
  payload?: Record<string, unknown>;
}

interface IUpdateActionResult {
  updateAction: (variables: IUpdateActionVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useMarkNotificationsAs

`useMarkNotificationsAs` hook that marks the notifications as read or seen.

```typescript theme={null}
const onSuccess = (data: IMessage[]) => {};

const onError = (error: Error) => {};

const { markNotificationsAs, isLoading, isError, error } = useMarkNotificationsAs({
  onSuccess,
  onError,
});
```

`useMarkNotificationsAs` hook args interface

```typescript theme={null}
interface IUseMarkNotificationsAsArgs {
  onSuccess?: (data: IMessage[]) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useMarkNotificationsAs` hook return interface

```typescript theme={null}
interface IMarkNotificationsAsVariables {
  messageId: IMessageId;
  seen: boolean;
  read: boolean;
}

interface IUseMarkNotificationsAsResult {
  markNotificationsAs: (args: IMarkNotificationsAsVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useRemoveNotification

`useRemoveNotification` hook allows you to remove a message. It will delete the message for the subscriber and will refetch the feed.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { removeNotification, isLoading, isError, error } = useRemoveNotification({
  onSuccess,
  onError,
});
```

`useRemoveNotification` hook args interface

```typescript theme={null}
interface IUseRemoveNotificationArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useRemoveNotification` hook return interface

```typescript theme={null}
interface IRemoveNotificationVariables {
  messageId: IMessageId;
}

interface IUseRemoveNotificationResult {
  removeNotification: (args: IRemoveNotificationVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useRemoveNotifications

<Note>This hook is available from version 0.23.1</Note>

`useRemoveNotifications` hook allows you to remove multiple messages with a limit of 100 messageIds in single call.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { removeNotifications, isLoading, isError, error } = useRemoveNotifications({
  onSuccess,
  onError,
});
```

`useRemoveNotifications` hook args interface

```typescript theme={null}
interface IUseRemoveNotificationArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useRemoveNotifications` hook return interface

```typescript theme={null}
interface IRemoveNotificationsVariables {
  messageIds: string[];
}

interface IUseRemoveNotificationResult {
  removeNotifications: (args: IRemoveNotificationsVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useRemoveAllNotifications

`useRemoveAllNotifications` hook allows you to remove all messages of all feeds. feedId can be used as param to delete only specific feed's messages.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { removeAllNotifications, isLoading, isError, error } = useRemoveAllNotifications({
  onSuccess,
  onError,
});
```

`useRemoveAllNotifications` hook args interface

```typescript theme={null}
interface IUseRemoveAllNotificationsArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useRemoveAllNotifications` hook return interface

```typescript theme={null}
interface IRemoveAllNotificationsVariables {
  feedId?: string;
}

interface IUseRemoveAllNotificationsResult {
  removeAllNotifications: (args: IRemoveAllNotificationsVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useTranslations

`useTranslations` hook allows you to get the reference to the [translations](/notification-center/client/react/customization#customize-the-ui-language) object.

```typescript theme={null}
const result = useTranslations();
```

`useTranslations` returns interface

```typescript theme={null}
interface ITranslations {
  lang: string;
  t: (key: string) => string;
  dateFnsLocale: () => Locale;
}
```

### useNovuTheme

`useNovuTheme` hook can be used to get the reference to the [theme](#the-theme-interface) object.

```typescript theme={null}
const result = useNovuTheme();
```

`useNovuTheme` hook return interface

```typescript theme={null}
interface INovuThemeProviderContext {
  theme: INovuTheme;
  common: ICommonTheme;
  colorScheme: ColorScheme;
}
```

#### The theme interface

```typescript theme={null}
interface INovuTheme {
  layout?: IThemeLayout;
  header?: IThemeHeader;
  popover?: IThemePopover;
  actionsMenu?: IThemeActionsMenu;
  notificationItem?: IThemeNotificationListItem;
  userPreferences?: IThemeUserPreferences;
  footer?: IThemeFooter;
  loaderColor?: string;
}
```

#### `IThemeLayout`

| Property                   | Default Value (Light Theme)            | Default Value - (Dark Theme)    |
| -------------------------- | -------------------------------------- | ------------------------------- |
| background                 | #FFFFFF                                | #1E1E26                         |
| boxShadow                  | 0px 5px 15px rgba(122, 133, 153, 0.25) | 0px 5px 20px rgba(0, 0, 0, 0.2) |
| wrapper.secondaryFontColor | #BEBECC                                | #525266                         |

#### `IThemeHeader`

| Property       | Default Value (Light Theme)                   | Default Value - (Dark Theme)                  |
| -------------- | --------------------------------------------- | --------------------------------------------- |
| badgeColor     | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) |
| badgeTextColor | #FFFFFF                                       | #FFFFFF                                       |
| fontColor      | #828299                                       | #FFFFFF                                       |

#### `IThemePopover`

| Property   | Default Value (Light Theme) | Default Value - (Dark Theme) |
| ---------- | --------------------------- | ---------------------------- |
| arrowColor | #FFFFFF                     | #1E1E26                      |

#### `IThemeNotificationListItem`

| Property                                | Default Value (Light Theme)                             | Default Value - (Dark Theme)                            |
| --------------------------------------- | ------------------------------------------------------- | ------------------------------------------------------- |
| seen.fontColor                          | #828299                                                 | #FFFFFF                                                 |
| seen.background                         | #F5F8FA                                                 | #23232B                                                 |
| seen.timeMarkFontColor                  | #BEBECC                                                 | #525266                                                 |
| unseen.fontColor                        | #828299                                                 | #FFFFFF                                                 |
| unseen.background                       | #FFFFFF                                                 | #292933                                                 |
| unseen.boxShadow                        | 0px 5px 15px rgba(122, 133, 153, 0.25)                  | 0px 5px 20px rgba(0, 0, 0, 0.2)                         |
| unseen.notificationItemBeforeBrandColor | linear-gradient(0deg,#FF512F 0%,#DD2476 100%)           | linear-gradient(0deg,#FF512F 0%,#DD2476 100%)           |
| unseen.timeMarkFontColor                | #828299                                                 | #828299                                                 |
| buttons.primary.backGroundColor         | linear-gradient(99deg,#DD2476 0% 0%, #FF512F 100% 100%) | linear-gradient(99deg,#DD2476 0% 0%, #FF512F 100% 100%) |
| buttons.primary.fontColor               | #FFFFFF                                                 | #FFFFFF                                                 |
| buttons.primary.removeCircleColor       | white                                                   | white                                                   |
| buttons.primary.fontFamily              | inherit                                                 | inherit                                                 |
| buttons.secondary.backGroundColor       | #F5F8FA                                                 | #3D3D4D                                                 |
| buttons.secondary.fontColor             | #525266                                                 | #FFFFFF                                                 |
| buttons.secondary.removeCircleColor     | #525266                                                 | #525266                                                 |
| buttons.secondary.fontFamily            | inherit                                                 | inherit                                                 |

#### `IThemeActionsMenu`

| Property        | Default Value (Light Theme) | Default Value - (Dark Theme) |
| --------------- | --------------------------- | ---------------------------- |
| dotsButtonColor | #A1A1B2                     | #525266                      |
| dropdownColor   | #FFFFFF                     | #292933                      |
| hoverColor      | #F5F8FA                     | #3D3D4D                      |
| fontColor       | #525266                     | #FFFFFF                      |

#### `IThemeUserPreferences`

| Property                                   | Default Value (Light Theme)                   | Default Value - (Dark Theme)                  |
| ------------------------------------------ | --------------------------------------------- | --------------------------------------------- |
| `settingsButtonColor`                      | #A1A1B2                                       | #525266                                       |
| `accordion.background`                     | #FFFFFF                                       | #292933                                       |
| `accordion.fontColor`                      | #525266                                       | #FFFFFF                                       |
| `accordion.secondaryFontColor`             | #828299                                       | #828299                                       |
| `accordion.boxShadow`                      | 0px 5px 15px rgba(122, 133, 153, 0.25)        | 0px 5px 20px rgba(0, 0, 0, 0.2)               |
| `accordion.arrowColor`                     | #828299                                       | #828299                                       |
| `accordion.arrowColor`                     | #EDF0F2                                       | #3D3D4D                                       |
| `accordionItem.fontColor.active`           | #525266                                       | #FFFFFF                                       |
| `accordionItem.fontColor.inactive`         | #BEBECC                                       | #828299                                       |
| `accordionItem.icon.active`                | #525266                                       | #FFFFFF                                       |
| `accordionItem.icon.inactive`              | #BEBECC                                       | #525266                                       |
| `accordionItem.switch.backgroundChecked`   | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) |
| `accordionItem.switch.backgroundUnchecked` | #BEBECC                                       | #3D3D4D                                       |
| `footer.logoTextColor`                     | #000000                                       | #FFFFFF                                       |
| `footer.logoPrefixFontColor`               | #A1A1B2                                       | #525266                                       |
| `loaderColor`                              | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) |

#### `IThemeFooter`

| Property            | Default Value (Light Theme) | Default Value - (Dark Theme) |
| ------------------- | --------------------------- | ---------------------------- |
| logoTextColor       | #000000                     | #FFFFFF                      |
| logoPrefixFontColor | #A1A1B2                     | #525266                      |

customization properties

| Property                   | type                                      | Default Value (Light Theme) | Default Value - (Dark Theme) |
| -------------------------- | ----------------------------------------- | --------------------------- | ---------------------------- |
| colorScheme                | string                                    | light                       | light                        |
| unseenBadgeColor           | string or [ISvgStopColor](#isvgstopcolor) | -                           | -                            |
| unseenBadgeBackgroundColor | string                                    | #FFFFFF                     | #1E1E26                      |

#### `ISvgStopColor`

| Property        | Default Value (Light Theme) | Default Value - (Dark Theme) |
| --------------- | --------------------------- | ---------------------------- |
| stopColor       | #FF512F                     | #FF512F                      |
| stopColorOffset | #DD2476                     | #DD2476                      |

## Others

### The notification `IMessage` model

`IMessage` model has the following properties:

| Property                  | Type                                      | Description                                                                                          |
| ------------------------- | ----------------------------------------- | ---------------------------------------------------------------------------------------------------- |
| \_id                      | string                                    | A unique Novu message identifier                                                                     |
| channel                   | [ChannelTypeEnum](#channeltypeenum)       | Use to specify the actual channel of this message (in\_app will be used here)                        |
| seen                      | boolean                                   | Whether the notification item was read by the user, changed when the user clicks on the notification |
| lastSeenDate              | ISODate                                   | When the user has last seen the notification                                                         |
| content                   | string                                    | An HTML string of the generated notification content with parsed and replaced variables              |
| templateIdentifier        | string                                    | A unique Novu workflow identifier                                                                    |
| payload                   | `Record<string, unknown>`                 | The payload object that was passed to the trigger even of the workflow.                              |
| createdAt                 | ISODate                                   | The creation date of the message                                                                     |
| cta.type                  | [ChannelCTATypeEnum](#channelctatypeenum) | The type of the CTA specified in the admin panel                                                     |
| cta.data.url              | string                                    | The redirect URL set in the admin panel, can be used to navigate on notification click               |
| cta.action.status         | boolean                                   | Indication whether the action occurred                                                               |
| cta.action.buttons        | [IMessageButton\[\]](#imessagebutton)     | Array of action buttons                                                                              |
| cta.action.result.payload | `Record<string, unknown>`                 | Payload object that send on updateAction method in useNotifications hook                             |
| cta.action.result.type    | [ButtonTypeEnum](#buttontypeenum)         | Type of the button                                                                                   |
| subscriber                | [SubscriberProps](#subscriberprops)       | Subscriber object that contains information about the subscriber                                     |

### SubscriberProps

| Property     | Type   | Description                                                         |
| ------------ | ------ | ------------------------------------------------------------------- |
| \_id         | string | Auto-generated identifier for the subscriber entity in the database |
| firstName    | string | First name of the subscriber                                        |
| subscriberId | string | identifier of the subscriber entity in the Novu Web Dashboard       |

### IMessageButton

| Property | Type                              | Description       |
| -------- | --------------------------------- | ----------------- |
| type     | [ButtonTypeEnum](#buttontypeenum) | Button type enum  |
| content  | string                            | Button inner text |

### ChannelCTATypeEnum

| Property | Value    |
| -------- | -------- |
| REDIRECT | redirect |

### ChannelTypeEnum

| Property | Value   |
| -------- | ------- |
| IN\_APP  | in\_app |
| EMAIL    | email   |
| SMS      | sms     |
| CHAT     | chat    |
| PUSH     | push    |

### ButtonTypeEnum

| Property  | Value     |
| --------- | --------- |
| PRIMARY   | primary   |
| SECONDARY | secondary |


# Customizing Notification Center
Source: https://v0.x-docs.novu.co/notification-center/client/react/customization

Learn how to customize the pre built notification center component partially or building your own notification center component from scratch using Novu provided hooks

## PopoverNotificationCenter Customization

`<PopoverNotificationCenter>` is a pre built notification center component that can be used to show notifications in your application. It is a popover component that can be placed anywhere in your application. A bell will appear on the page. On click of that bell, a popover will appear. Checkout all customizations and available [props](/notification-center/client/react/api-reference#popovernotificationcenter). If you are looking for a component without popover use regular `<NotificationCenter>` component. Checkout [props](/notification-center/client/react/api-reference#notificationcenter) of this component. Few selected customization options are explained below:-

### Implementing custom bell icon

It is common that you might have a special set of icons you use within your application and you will want to replace the default: `NotificationBell` coming from our library.

For this you can easily switch the `NotificationBell` with your own bell. Just make sure you pass the `unseenCount` param inside and use it accordingly.

```jsx theme={null}
<PopoverNotificationCenter colorScheme="dark">
  {({ unseenCount }) => (
    <CustomBell
      unseenCount={unseenCount}
      colorScheme="dark"
      unseenBadgeBackgroundColor="#FFFFFF"
      unseenBadgeColor="#FF0000"
    />
  )}
</PopoverNotificationCenter>
```

### Dark mode support

To support dark mode in your application the notification center component can receive a `colorScheme` prop that can receive either `dark` or `light` mode.

```tsx theme={null}
<PopoverNotificationCenter colorScheme={"dark" || "light"}>
  {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
</PopoverNotificationCenter>
```

### Popover positioning

Use `position`  and `offset` prop to position the popover relative to the Bell icon

```jsx theme={null}
<PopoverNotificationCenter position="left-start" offset={20}>
  {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
</PopoverNotificationCenter>
```

### Header, Footer and Empty state

Use `header`, `footer` and `emptyState` prop to customize the header, footer and empty state of notification center.

```jsx theme={null}
const Header = () => {
  return <span> My custom header </span>;
};

const Footer = () => {
  return <span> My custom footer </span>;
};

const EmptyState = () => {
  return <span> My custom empty state </span>;
};

<PopoverNotificationCenter
  colorScheme="dark"
  header={() => <Header />}
  footer={() => <Footer />}
  emptyState={<EmptyState />}
>
  {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
</PopoverNotificationCenter>;
```

### Notification item

Use the listItem prop to show custom notification items.

```jsx theme={null}
<PopoverNotificationCenter
  colorScheme={colorScheme}
  onNotificationClick={handlerOnNotificationClick}
  onActionClick={handlerOnActionClick}
  listItem={(
    notification,
    handleActionButtonClick,
    handleNotificationClick
  ) => {
    return (
      <a
        href="/"
        onClick={(e) => {
          e.preventDefault();
          handleNotificationClick();
        }}
      >
        {notification.content}
      </a>
    );
  }}
>
  {({ unseenCount }) => {
    return <NotificationBell unseenCount={unseenCount} />;
  }}
</PopoverNotificationCenter>
```

### Customize the UI language

If you want to use a language other than english for the UI, the `NovuProvider` component can accept an optional `i18n` prop.

```typescript theme={null}
<NovuProvider
  subscriberId={"USER_ID"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
  i18n="en"
>
  <PopoverNotificationCenter colorScheme="dark">
    {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
  </PopoverNotificationCenter>
</NovuProvider>
```

The `i18n` prop can accept 2 different types of values

* 2 letter language string

```typescript theme={null}
i18n = "en";
```

<Accordion title="Supported Language">
  * `af` (Afrikaans)
  * `am` (Amharic)
  * `ar` (Arabic)
  * `as` (Assamese)
  * `az` (Azerbaijani)
  * `ba` (Bashkir)
  * `be` (Belarusian)
  * `bg` (Bulgarian)
  * `bh` (Bihari)
  * `bn` (Bengali)
  * `bs` (Bosnian)
  * `ca` (Catalan)
  * `cs` (Czech)
  * `da` (Danish)
  * `de` (German)
  * `el` (Greek)
  * `en` (English)
  * `es` (Spanish)
  * `eu` (Basque)
  * `fa` (Farsi)
  * `fi` (Finnish)
  * `fr` (French)
  * `ga` (Irish)
  * `gl` (Galician)
  * `gu` (Gujarati)
  * `he` (Hebrew)
  * `hi` (Hindi)
  * `hr` (Croatian)
  * `hu` (Hungarian)
  * `hy` (Armenian)
  * `id` (Indonesian)
  * `ig` (Igbo)
  * `it` (Italian)
  * `ja` (Japanese)
  * `ka` (Kannada)
  * `kk` (Kazakh)
  * `km` (Khmer)
  * `ko` (Korean)
  * `ku` (Kurdish)
  * `lo` (Lao)
  * `lt` (Lithuanian)
  * `lv` (Latvian)
  * `ml` (Malayalam)
  * `mr` (Marathi)
  * `ms` (Malay)
  * `nb` (Norwegian)
  * `ne` (Nepali)
  * `nl` (Dutch)
  * `or` (Odia)
  * `pa` (Punjabi)
  * `pl` (Polish)
  * `pt` (Portuguese)
  * `ro` (Romanian)
  * `ru` (Russian)
  * `sa` (Sanskrit)
  * `sd` (Sindhi)
  * `si` (Sinhala)
  * `sm` (Samoan)
  * `sq` (Albanian)
  * `sv` (Swedish)
  * `sq` (Albanian)
  * `ta` (Tamil)
  * `te` (Telugu)
  * `th` (Thai)
  * `tl` (Tagalog)
  * `tr` (Turkish)
  * `uk` (Ukrainian)
  * `ur` (Urdu)
  * `uz` (Uzbek)
  * `vi` (Vietnamese)
  * `zh` (Chinese)
  * `zu` (Zulu)
</Accordion>

* Translation object

```typescript theme={null}
i18n={{
  // Make sure that the following is a proper language code,
  // since this is used by Intl.RelativeTimeFormat in order to calculate the relative time for each notification
  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
  lang: "de",

  translations: {
    poweredBy: "von",
    markAllAsRead: "Alles als gelesen markieren",
    notifications: "Benachrichtigungen",
    settings: "Einstellungen",
  },
}}

```

<Tip>Novu uses *`en`* as the default value for i18n</Tip>

### Customization using `styles` prop

`styles` prop can be used to cutomise styling of each component of notification center. Read more about [styles prop](/notification-center/client/react/api-reference#styles)

```javascript theme={null}
export const styles = {
  bellButton: {
    root: {
      marginTop: "20px",
      svg: {
        color: "#AFE1AF",
        fill: "white",
        minWidth: "20px",
        minHeight: "20px"
      }
    },
    dot: {
      rect: {
        fill: "white",
        strokeWidth: "0",
        width: "3px",
        height: "3px",
        x: 10,
        y: 2
      }
    }
  }
}
```

<Accordion title="Customizing styles">
  ```javascript theme={null}
  const primaryColor = "white";
  const secondaryColor = "#AFE1AF";
  const primaryTextColor = "#0C0404";
  const secondaryTextColor = "#494F55";
  const unreadBackGroundColor = "#869F9F";
  const primaryButtonBackGroundColor = unreadBackGroundColor;
  const secondaryButtonBackGroundColor = "#C6DFCD";
  const dropdownBorderStyle = "2px solid #AFE1AF";
  const tabLabelAfterStyle = "#AFE1AF !important";
  const ncWidth = "350px !important";

  export const styles = {
    bellButton: {
      root: {
        marginTop: "20px",
        svg: {
          color: secondaryColor,
          fill: primaryColor,
          minWidth: "20px",
          minHeight: "20px"
        }
      },
      dot: {
        rect: {
          fill: primaryColor,
          strokeWidth: "0",
          width: "3px",
          height: "3px",
          x: 10,
          y: 2
        }
      }
    },
    unseenBadge: {
      root: { color: primaryTextColor, background: secondaryColor }
    },
    popover: {
      root: { zIndex: -99 },
      arrow: {
        backgroundColor: primaryColor,
        borderLeftColor: secondaryColor,
        borderTopColor: secondaryColor
      },
      dropdown: {
        border: dropdownBorderStyle,
        borderRadius: "10px",
        marginTop: "25px",
        maxWidth: ncWidth
      }
    },
    header: {
      root: {
        backgroundColor: primaryColor,
        "&:hover": { backgroundColor: primaryColor },
        cursor: "pointer",
        color: primaryTextColor
      },
      cog: { opacity: 1 },
      markAsRead: {
        color: primaryTextColor,
        fontSize: "14px"
      },
      title: { color: primaryTextColor },
      backButton: {
        color: primaryTextColor
      }
    },
    layout: {
      root: {
        background: primaryColor,
        maxWidth: ncWidth
      }
    },
    loader: {
      root: {
        stroke: primaryTextColor
      }
    },
    accordion: {
      item: {
        backgroundColor: secondaryColor,
        ":hover": {
          backgroundColor: secondaryColor
        }
      },
      content: {
        backgroundColor: secondaryColor,
        borderBottomLeftRadius: "7px",
        borderBottomRightRadius: "7px"
      },
      control: {
        ":hover": {
          backgroundColor: secondaryColor
        },
        color: primaryTextColor,
        title: {
          color: primaryTextColor
        }
      },
      chevron: {
        color: primaryTextColor
      }
    },
    notifications: {
      root: {
        ".nc-notifications-list-item": {
          backgroundColor: secondaryColor
        }
      },
      listItem: {
        layout: {
          borderRadius: "7px",
          color: primaryTextColor,
          "div:has(> .mantine-Avatar-root)": {
            border: "none",
            width: "20px",
            height: "20px",
            minWidth: "20px"
          },
          ".mantine-Avatar-root": {
            width: "20px",
            height: "20px",
            minWidth: "20px"
          },
          ".mantine-Avatar-image": {
            width: "20px",
            height: "20px",
            minWidth: "20px"
          }
        },
        timestamp: { color: secondaryTextColor, fontWeight: "bold" },
        dotsButton: {
          path: {
            fill: primaryTextColor
          }
        },
        unread: {
          "::before": { background: unreadBackGroundColor }
        },
        buttons: {
          primary: {
            background: primaryButtonBackGroundColor,
            color: primaryTextColor,
            "&:hover": {
              background: primaryButtonBackGroundColor,
              color: secondaryTextColor
            }
          },
          secondary: {
            background: secondaryButtonBackGroundColor,
            color: secondaryTextColor,
            "&:hover": {
              background: secondaryButtonBackGroundColor,
              color: secondaryTextColor
            }
          }
        }
      }
    },
    actionsMenu: {
      item: { "&:hover": { backgroundColor: secondaryColor } },
      dropdown: {
        backgroundColor: primaryColor
      },
      arrow: {
        backgroundColor: primaryColor,
        borderTop: "0",
        borderLeft: "0"
      }
    },
    preferences: {
      item: {
        title: { color: primaryTextColor },
        divider: { borderTopColor: primaryColor },
        channels: { color: secondaryTextColor },
        content: {
          icon: { color: primaryTextColor },
          channelLabel: { color: primaryTextColor },
          success: { color: primaryTextColor }
        }
      }
    },
    tabs: {
      tabLabel: {
        "::after": { background: tabLabelAfterStyle },
        ":hover": { color: tabLabelAfterStyle },
        "[data-active]": { color: tabLabelAfterStyle }
      },
      tabsList: { borderBottomColor: primaryColor }
    }
  };
  ```
</Accordion>

[![Edit custom-styles-novu-nc](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/custom-styles-novu-nc-2jd46m?fontsize=14\&module=%2Fsrc%2Fstyles.js\&moduleview=1\&theme=dark)

## Customization Using Hooks

If you don't want to use our pre built component then, you can build your own notification center using hooks. `@novu/notification-center` react package provides many hooks like `useNotifications`, `useFetchNotifications`, `useUpdateUserPreferences`. Checkout all available [hooks](/notification-center/client/react/api-reference#hooks). All the hooks should be defined inside the [NovuProvider](/notification-center/client/react/api-reference#novuprovider) component. Most of the hooks are based on the `@tanstack/react-query` library.

Checkout below example on how to use `useNotifications` and `useFetchNotifications` hook
[![Edit useNotifications-useFetchNotifications-hook](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/usenotifications-usefetchnotifications-hook-2t6sgz?fontsize=14\&hidenavigation=1\&theme=dark)


# React Get Started
Source: https://v0.x-docs.novu.co/notification-center/client/react/get-started

Learn how to add novu powered In-App notification center to your React app

Novu provides the `@novu/notification-center` a React library that helps to add a fully functioning notification center to your web application in minutes. Let's do a quick recap on how you can easily use it in your application.

1. Install `@novu/notification-center` npm package in your react app

```jsx theme={null}
npm install @novu/notification-center
```

2. Add the below code in the app.tsx file

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
  IMessage,
} from "@novu/notification-center";

function Novu() {
  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <PopoverNotificationCenter colorScheme="dark">
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}
```

[![Edit kind-nova-xv6s9g](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark)

Go to this react app browser tab, there will be a bell icon. On clicking that bell icon, you will see a notification component popover

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Use your own backend and socket URL

By default, Novu's hosted services of API and socket are used. If you want, you can override them and configure your own.

```tsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
} from "@novu/notification-center";

function Novu() {
  return (
    <NovuProvider
      backendUrl={"YOUR_BACKEND_URL"}
      socketUrl={"YOUR_SOCKET_URL"}
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <PopoverNotificationCenter colorScheme="dark">
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}
```

## Notification center without bell

If you don't want to show the bell icon, you can directly render the notification center component without passing the bell, use `<NotificationCenter>` component in place of `<PopoverNotificationCenter>`

```jsx theme={null}
import {
  NovuProvider,
  NotificationCenter,
} from "@novu/notification-center";

<NovuProvider
  subscriberId={"SUBSCRIBER_ID"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
>
  <NotificationCenter colorScheme="dark" />
</NovuProvider>
```

## HMAC Encryption

When Novu's user adds the notification center to their application they are required to pass a `subscriberId` which identifies the user's end-customer, and the application Identifier which is acted as a public key to communicate with the notification feed API.

A malicious actor can access the user feed by accessing the API and passing another `subscriberId` using the public application identifier.

HMAC encryption will make sure that a `subscriberId` is encrypted using the secret API key, and those will prevent malicious actors from impersonating users.

### Enabling HMAC Encryption

In order to enable Hash-Based Message Authentication Codes, you need to visit the admin panel In-App settings page and enable HMAC encryption for your environment.

<Frame>
  <img />
</Frame>

1. Next step would be to generate an HMAC encrypted subscriberId on your backend:

```jsx theme={null}
import { createHmac } from "crypto";

const hmacHash = createHmac("sha256", process.env.NOVU_API_KEY)
  .update(subscriberId)
  .digest("hex");
```

2. Then pass the created HMAC to your client side application forward it to the component:

```jsx theme={null}
<NovuProvider
  subscriberId={"SUBSCRIBER_ID_PLAIN_VALUE"}
  subscriberHash={"SUBSCRIBER_ID_HASH_VALUE"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
>
  <NotificationCenter colorScheme="dark" />
</NovuProvider>
```

<Info>If HMAC encryption is active in In-App provider settings and  `subscriberHash` along with `subscriberId` is not provided, then notification center will not load</Info>

## Notification Actions

### onNotificationClick

This function is invoked when the user clicks anywhere on the notification except for CTA actions.

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
  IMessage,
} from "@novu/notification-center";

function Novu() {
  function handleOnNotificationClick(message: IMessage) {
    // your logic to handle the notification click
    if (message?.cta?.data?.url) {
      window.location.href = message.cta.data.url;
    }
  }

  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <PopoverNotificationCenter
        colorScheme="dark"
        onNotificationClick={handleOnNotificationClick}
      >
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}
```

### onActionClick

This function is invoked when the user clicks on the action CTA buttons of the notification

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  IMessage,
  MessageActionStatusEnum,
  useUpdateAction,
  ButtonTypeEnum,
  NotificationBell,
} from "@novu/notification-center";

export default function Novu() {

  const CustomNotificationCenter = () => {
    const { updateAction } = useUpdateAction();

    const handleOnActionClick = async (
      templateIdentifier: string,
      btnType: ButtonTypeEnum,
      notification: IMessage
    ) => {
      if (templateIdentifier === "friend-request") {
        if (btnType === "primary") {
          /** Call your API to accept the friend request here **/

          /** And then update Novu that this action has been taken, so the user won't see the button again **/
          updateAction({
            messageId: notification._id,
            actionButtonType: btnType,
            status: MessageActionStatusEnum.DONE,
          });
        }
      }
    };

    return (
      <PopoverNotificationCenter
        colorScheme={"dark"}
        onActionClick={handleOnActionClick}
      >
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    );
  };

  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <CustomNotificationCenter />
    </NovuProvider>
  );
}
```

<Note>CTA buttons text and redirect url field supports dynamic variables</Note>

## Avatar Icons

Avatar images can be shown with in-app notifications. To do so, enable `Add an Avatar` option in in-app step editor as shown below

<Frame>
  <img />
</Frame>

**There are 3 ways to show the avatar images in the notifications:**

<Frame>
  <img />
</Frame>

### User Avatar

This option will show the avatar of the actor user. actor field can be sent while triggering the worklfow. Each subscriber has `avatar` field. For this option to work actor should have `avatar` field set with valid publicly accessible image URL. If the actor doesn't have `avatar` field, then the default avatar will be shown. Worklfow trigger example with avatar

```javascript theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: 'subscriberId_1',
  },
  payload: {
    "key": "value"
  },
  actor: "subscriberId_2"
});
```

Here subscriberId\_2 is used as actor and workflow is triggered to subscriberId\_1

### Static Avatar Url

This option can be used if you want to show same, static and custom avatar icon for each in-app notification of this workflow in-app step. Make sure to toggle off **User Avatar** option to enable this. This is a input field where only valid publicly accessible image URL can be entered. Currently variables are not supported in this field.

### System Avatar Icons

Novu supports 6 system avatar icons. These are default icons that can be selected as avatar icon. Once selected, same icon will be used as avatar icons for all notifications of this in-app step.

## Realtime sockets

Novu provides a real-time socket API for you to consume and get updates about new notifications added to the user's feed. To use the socket connection you can use the `useSocket` hook provided by the `@novu/notification-center` library. Let's see an example of that:

```tsx theme={null}
import { NovuProvider, useSocket } from "@novu/notification-center";

function Novu() {
  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <CustomNotificationCenter />
    </NovuProvider>
  );
}

function CustomNotificationCenter() {
  const { socket } = useSocket();

  useEffect(() => {
    if (socket) {
      socket.on("notification_received", (data) => {
        console.log(data);
      });
    }

    return () => {
      if (socket) {
        socket.off("notification_received");
      }
    };
  }, [socket]);

  return <></>;
}
```

There are three sockets events available:

1. `unseen_count_changed`
2. `unread_count_changed`
3. `notification_received`

### Toast notification

Novu does not have a native toast component. However, if your project is using any UI library like chakra, material-ui, mantine then toast component (snackbar in case of material-ui) of these libraries can be used with `useSocket` hook. Add the toast opening code in `socket.on` callback.

```javascript toast.tsx theme={null}
socket.on("notification_received", (data) => {
  console.log(data);
  // set received notification content as toast content
  setToastContent(data.content)
  // open the toast
  openToast(true)
});
```

## Example

[![Edit kind-nova-xv6s9g](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark)

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="The notification center is not loading properly.">
    Possible reasons for the notification center not loading properly:

    * Invalid subscriberId
    * Invalid applicationIdentifier
    * Invalid subscriberHash (in case of active HMAC encryption)
    * Invalid backendUrl (in case of self-hosted)
    * Invalid socketUrl (in case of self-hosted)
  </Accordion>

  <Accordion title="There is a render error due to the notification center in React.">
    The notification center should be wrapped in `<NovuProvider>`
  </Accordion>

  <Accordion title="What is the difference between a redirect URL and CTA?">
    The redirect URL is for the entire notification item, When the user clicks the notification, the user will be routed to that url. CTA are two call-to-action buttons. `onNotificationClick` function prop is used for redirecting url and the `onActionClick` function prop is used for CTA.
  </Accordion>

  <Accordion title="Can bell icon in Novu dashboard be used for in-app channel testing?">
    Bell icon and notification center in Novu dashboard is only for receiving system related notifications like user you invited has joined, password reset request sent. It can not to used to test notification center. Consider using our [codesandbox example](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark) instead.
  </Accordion>

  <Accordion title="How to fix CORS error with notification center?">
    Our notification center is configures for all hosts. Please disable root level `withCredentials` config in axios or fetch http requests.
  </Accordion>
</AccordionGroup>


# Configuring Multiple Tabs
Source: https://v0.x-docs.novu.co/notification-center/client/react/multiple-tabs



Novu allows to create a multi-tab experience for a notification center, in a way you can fetch the notifications feed using a filtered query.

### Defining stores

To create multiple stores you can use the prop `stores` on the `NovuProvider` component. Each store has `storeId` property that will be used to interact with information related to this store.

```tsx theme={null}
<NovuProvider
  stores={[
    /**
	storeId and feedIdentifier must be identical and should be copied from In-App editor feed
  */
    {
      storeId: "product-updates",
      query: { feedIdentifier: "product-updates" },
    },
    { storeId: "user-activity", query: { feedIdentifier: "user-activity" } },
  ]}
  subscriberId={"SUBSCRIBER_ID"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
>
  <PopoverWrapper />
</NovuProvider>
```

Using the `query` object multiple fields can be passed for feed API:

* `feedIdentifier` - Can be configured and created on the WEB UI
* `seen` - Identifies if the notification has been seen or not

After specifying the `stores` prop, you can use the `storeId` property to interact with the store.

### Managing feeds on the web UI

1. How to add a new feed or select existing feed for In-App step?

To add a new feed, enable *Use Feeds* checkbox in In-App editor. Select from existing feeds or create a new feed by writing in the input field and then clicking on plus icon in the right side.

<Frame>
  <img />
</Frame>

2. How to copy `feedIdentifier` (`storeId`)

To copy `feedIdentifier` (`storeId`) click on the feed name of existing feeds. copy three dot icon. a menu will appear. click on Copy ID option to copy selected feed's `feedIdentifier`

<Frame>
  <img />
</Frame>

<Info>
  By specifying only a storeId, without a query, you could get all notifications.
</Info>

### Using `tabs` prop on the notification center

```tsx theme={null}
<PopoverNotificationCenter
  colorScheme="dark"
  tabs={[
    // name can be any custom name
    { name: "Product Updates", storeId: "product-updates" },
    { name: "User Activity", storeId: "user-activity" },
  ]}
  colorScheme={colorScheme}
  onNotificationClick={handlerOnNotificationClick}
  onActionClick={handlerOnActionClick}
>
  {({ unseenCount }) => {
    return (
      <NotificationBell colorScheme={colorScheme} unseenCount={unseenCount} />
    );
  }}
</PopoverNotificationCenter>
```

<Frame>
  <img />
</Frame>

## Example

[![Edit tabs-in-in\_app](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/tabs-in-in-app-xdk74x?fontsize=14\&hidenavigation=1\&theme=dark)

## Important Links

<CardGroup>
  <Card title="Get all feeds" icon="plug" href="/api-reference/feeds/get-feeds" />

  <Card title="Create a new feed" icon="plug" href="/api-reference/feeds/create-feed" />

  <Card title="Delete a feed" icon="plug" href="/api-reference/feeds/delete-feed" />
</CardGroup>


# Subscriber Preference
Source: https://v0.x-docs.novu.co/notification-center/client/react/preference



By default, Novu will show the subscriber preferences cog icon on the notification center component. If you want to hide it, you can use the prop `showUserPreferences` on the `PopoverNotificationCenter` component.

Users can enable/disable any active channel in the workflow using subscriber preferences

<img />

## Get subscriber preferences

<CodeGroup>
  ```typescript Node.JS theme={null}
  import { Novu } from "@novu/node";

  const novu = new Novu("<NOVU_API_KEY>");

  // 111 is subscriberId
  await novu.subscribers.getPreference("111");
  ```
</CodeGroup>

## Update subscriber preference for a workflow

<CodeGroup>
  ```typescript Node.JS theme={null}
  import { Novu, ChannelTypeEnum } from "@novu/node";

  const novu = new Novu("<NOVU_API_KEY>");

  // enable in_app channel
  await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
    enabled: true,
    channel: { type: ChannelTypeEnum.IN_APP, enabled: true },
  });

  // enable email channel
  await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
    enabled: true,
    channel: { type: ChannelTypeEnum.EMAIL, enabled: true },
  });
  ```
</CodeGroup>

Read more about [subscriber preference](/subscribers/preferences).


# Vue Component
Source: https://v0.x-docs.novu.co/notification-center/client/vue



The `@novu/notification-center-vue` package provides a Vue component wrapper over the Notification Center Web Component that you can use to integrate the notification center into your Vue application.

## Installation

```bash theme={null}
npm install @novu/notification-center-vue
```

<Info>Novu supports only Vue 3.</Info>

## The plugin

The Notification Center Vue plugin can be used to register the `NotificationCenterComponent` as a global component. This is the recommended way to use the component.

```typescript theme={null}
import { createApp } from "vue";
import NotificationCenterPlugin from "@novu/notification-center-vue";
import "@novu/notification-center-vue/dist/style.css";
// your app component
import App from "./App.vue";

createApp(App).use(NotificationCenterPlugin).mount("#app");
```

## Example usage

```html theme={null}
<script lang="ts">
  export default {
    data() {
      return {
        applicationIdentifier: import.meta.env.VITE_NOVU_APPLICATION_IDENTIFIER,
        subscriberId: import.meta.env.VITE_NOVU_SUBSCRIBER_ID,
      };
    },
    methods: {
      sessionLoaded() {
        console.log("Notification Center Session Loaded!");
      },
    },
  };
</script>

<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
  />
</template>
```

By default, the `NotificationCenterComponent` renders the default bell button that opens the notification center when clicked, but it can be customized.

## Custom Bell Button

You can pass the custom bell button component as the default slot to the `NotificationCenterComponent` and it will be used to open the notification center. The `NotificationCenterComponent` also accepts a scoped slot which exposes the `unseenCount` property - the number of unseen notifications counts.

```tsx theme={null}
<script lang="ts">
  export default {
    data() {
      return {
        applicationIdentifier: import.meta.env.VITE_NOVU_APPLICATION_IDENTIFIER,
        subscriberId: import.meta.env.VITE_NOVU_SUBSCRIBER_ID,
      };
    },
    methods: {
      sessionLoaded() {
        console.log('Notification Center Session Loaded!');
      },
    },
  };
</script>

<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>
```

## Example

* [Vue Notification Center Example](https://github.com/novuhq/examples/tree/main/vue-notification-center-example)
* [CodeSandBox Link 🔗](https://codesandbox.io/p/sandbox/novu-vue-in-app-88p8vx)

## Props

The `NotificationCenterComponent` accepts the same set of props as the [Web Component](./web-component#properties).

It also accepts an extra prop

| Prop     | Type      | Description                                                                                                                                          |
| -------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| triggers | string\[] | This is an Array of events that controls the underlying popper component's trigger. [Read more here](https://floating-vue.starpad.dev/api/#triggers) |


# Web Component
Source: https://v0.x-docs.novu.co/notification-center/client/web-component



The Notification Center Web Component is a custom element that can be used in any web application. It is built by wrapping the React components and consists from its core the three pieces:  `NovuProvider`,  `PopoverNotificationCenter`, and  `NotificationBell` combined together into one.

## ESM module[](https://docs.novu.co/notification-center/web-component#esm-module)

Make sure that you have installed the `@novu/notification-center` package:

```bash theme={null}
npm install @novu/notification-center
```

Then, import the web component and register it as a custom element:

```tsx theme={null}
import { NotificationCenterWebComponent } from "@novu/notification-center";

customElements.define(
  "notification-center-component",
  NotificationCenterWebComponent
);
```

After that, you can use the web component in your HTML:

```html theme={null}
<!-- HTML -->
<notification-center-component
  style="display: inline-flex"
  application-identifier="APPLICATION_IDENTIFIER"
  subscriber-id="SUBSCRIBER_ID"
></notification-center-component>
<script>
  // here you can attach any callbacks, interact with the Notification Center Web Component API
  let nc = document.getElementsByTagName("notification-center-component")[0];
  nc.onLoad = () => console.log("Notification Center session loaded!");
</script>
```

**Please note:** that the properties are named with a `kebab-case` in the HTML, but depending on the technology you use it might be a `camelCase`, for ex. Vue/Angular props are bound with variables using that convention.

### Example

[CodeSandBox Link 🔗](https://codesandbox.io/s/novu-web-component-esm-rltcr5)

## Bundled version (preview)

Sometimes you might not be able to use the ESM module, for example in the WordPress environment. In that case, you can use the bundled version of the Notification Center Web Component that is available on the CDN.

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    ...
    <script src="​https://web-component.novu.co/index.js"></script>
  </head>
  <body>
    <notification-center-component
      style="display: inline-flex"
      application-identifier="APPLICATION_IDENTIFIER"
      subscriber-id="SUBSCRIBER_ID"
    ></notification-center-component>
    <script>
      // here you can attach any callbacks, interact with the web component API
      let nc = document.getElementsByTagName(
        "notification-center-component"
      )[0];
      nc.onLoad = () => console.log("hello world!");
    </script>
  </body>
</html>
```

### Example

[CodeSandBox Link 🔗](https://codesandbox.io/s/novu-web-component-bundled-rgrj5r?file=/index.html)

## Properties

The Notification Center Web Component has a few properties that you can use to customize the behavior of the component. The only required property is `applicationIdentifier`.

If you are using TypeScript, then you might want to check the `NotificationCenterComponentProps` interface.

| Prop                       | Type                                                                                         | Description                                                                                                                                                                                                                                                                                                  |
| -------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| backendUrl                 | string                                                                                       | Custom API location in case of self-hosted version of Novu.                                                                                                                                                                                                                                                  |
| socketUrl                  | string                                                                                       | Custom WebSocket Service location in case of self-hosted version of Novu.                                                                                                                                                                                                                                    |
| subscriberId               | string                                                                                       | The subscriberId is a custom identifier used when identifying your users within the Novu platform.                                                                                                                                                                                                           |
| applicationIdentifier      | string                                                                                       | Is a public identifier used to identify your application, can be found in the Novu Admin panel.                                                                                                                                                                                                              |
| subscriberHash             | string                                                                                       | The hashed subscriber id. [Read more about hmac encryption](/notification-center/client/react/get-started#hmac-encryption).                                                                                                                                                                                  |
| stores                     | object\[]                                                                                    | The array of the store items that are bound with the feed, it's used together with tabs property if you would like to have separate feeds in the notification center. [Read more here](/notification-center/client/react/multiple-tabs)                                                                      |
|                            |                                                                                              |                                                                                                                                                                                                                                                                                                              |
| tabs                       | object\[]                                                                                    | The array of items that do describe the tabs/feeds, they are bound with the stores property. [Read more here](/notification-center/client/react/multiple-tabs).                                                                                                                                              |
| showUserPreferences        | boolean                                                                                      | The flag indicating whether the user preference settings should be visible or not.                                                                                                                                                                                                                           |
| allowedNotificationActions | boolean                                                                                      | The flag indicating whether to show/hide the dots menu for actions performed on a notification.                                                                                                                                                                                                              |
| popoverConfig              | object                                                                                       | The object defining how the popover should be positioned. It's properties are position and offset.                                                                                                                                                                                                           |
| popover                    | object                                                                                       | The object defining how the popover should be positioned. It's properties are position and offset. popover is deprecated, use popoverConfig instead.                                                                                                                                                         |
| theme                      | [INovuTheme](/notification-center/client/react/api-reference#the-theme-interface)            | The object defining the the light/dark styles of the Notification Center component. We discourage you to use this prop to do the styling, instead it's recommended to use the styles property.                                                                                                               |
| styles                     | [NotificationCenterStyles](/notification-center/client/react/api-reference#styles-interface) | The object allows you to define the custom CSS code.                                                                                                                                                                                                                                                         |
| colorScheme                | string                                                                                       | The prop defines which color version of the styles the component should set. The options are light and dark.                                                                                                                                                                                                 |
| i18n                       | object                                                                                       | The object allowing to [customize the UI language](/notification-center/client/react/customization#customize-the-ui-language).                                                                                                                                                                               |
| onLoad                     | function                                                                                     | The callback function that is called when the session is successfully initiated. It receives the first argument object with the organization property. There is a sibling property sessionLoaded that might be used in environments that do not allow to use properties with the prefix on, like in Angular. |
| onNotificationClick        | function                                                                                     | The callback function that is called when the user has clicked on the notification. The first argument it receives is the notification object. There is a sibling property notificationClicked.                                                                                                              |
| onUnseenCountChanged       | function                                                                                     | The callback function that is called when the unseen notifications count changes. The first argument it receives is the number of unseen notifications count. There is a sibling property unseenCountChanged.                                                                                                |
| onActionClick              | function                                                                                     | The callback function that is called when user clicks on one of the notification buttons (primary/secondary). The arguments it receives are: template identifier, button type, and notification object. There is a sibling property actionClicked.                                                           |
| onTabClick                 | function                                                                                     | The callback function that is called when user clicks on the feed tab. The first arguments it receives is the tab object. There is a sibling property tabClicked.                                                                                                                                            |

## Limitations

It's important to note that there are some limitations when using the Web Component compared to the React version:

* You get an all-in-one component
* It doesn't support the `children, header, footer, emptyState, listItem` props
* It's a wrapped react component, which means a bigger bundle size (we are working on it to make it smaller)


# Introduction to Notification Center
Source: https://v0.x-docs.novu.co/notification-center/introduction

Learn more about Novu's Notification Center.

The notification center is a component, also sometimes referred to as a widget that furnishes your web application with a beautiful and smooth In-App notification experience for users.

In-App notifications are different from push notifications in the sense that In-App notifications are consumed by the user in your app itself, whether push notifications are shown on the device level. Read more about [push channel and supported providers.](/channels-and-providers/push/overview)

Novu provides a pre-built, ready-to-use, and customizable UI component. It also allows you to bring your own UI via a headless component which can be used to add In-App notifications to any platform.

<iframe />

## Example

[![Edit kind-nova-xv6s9g](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark)

## Why use the Novu notification center?

* Users can manage subscriber preferences from the notification center itself.
* You want to notify about any product activity related to the user.
* Prebuilt UI component so no need to build UI from scratch.
* Highly customizable as per your product design system.
* Multi-device real-time notification experience powered by web sockets.
* Secure your connection using HMAC encryption.
* Have multi-tabs notification experience.

## Concepts

1. `In-App notification`:- In-App notification is a message sent to the subscriber using an In-App channel step in the workflow.
2. `In-App notifications feed`:- List of all In-App messages sent to a particular subscriber.
3. `feeds`:- feeds are stores/tabs in which In-App messages can be grouped. One message can be in only one feed.
4. `notification actions`:- Notification actions are cta buttons below notification content that can be clicked to perform any action or external API call.
5. `redirect url`:- When a single notification item from the list is clicked then it can be configured to perform an action or redirect to any URL.

## UI Libraries

1. [React](/notification-center/client/react/get-started)
2. [Vue](/notification-center/client/vue)
3. [Angular](/notification-center/client/angular)
4. [Web Component](/notification-center/client/web-component)
5. [Headless](/notification-center/client/headless/get-started)

## Backend SDK Methods

[Backend sdk methods](/notification-center/backend/methods)


# Environments
Source: https://v0.x-docs.novu.co/platform/environments

Learn about environments in Novu

Novu runs all your requests in the context of an environment. By default, Novu creates two environments when your account was just created, `development` and `production`.

## Development environment

The development environment is used for testing purposes and validating notification changes prior to committing them to the production environment.

## Production environment

It will be your live/production environment, you cannot make changes to this environment directly. You will first have to make the changes in the `development` environment and then promote it to `production`. This is a read-only environment.

## Data associated with environments

Novu will separate most of the data associated with your account based on the current accessed environment. This will include:

* Subscribers
* Workflows
* Messages
* Execution logs
* Connected integrations
* Notification feeds
* Brand related assets and settings

Each environment will be accessed using a separate credential set:

* **Application Identifier** - This is a public identifier used in client-side applications to identify your application. It is unique to an environment in an organization and is different from `Provider Identifier`.
* **Provider Identifier** - This is an identifier for a provider in a channel. For example, say you're using email notifications. Here, two different providers will have two different `Provider Identifier`. Even if you're using two different integration of the same provider, you'll have two different `Provider Identifier`, each unique to one integration. For example, if you've two slack integrations, they will have two different `Provider Identifier`.
* **API Secret Key** - A secret key used when communicating with the `Novu API` from your backend services.

We suggest configuring these key sets based on your active environment, the same as you would use to manage different service credentials and serve them based on the current environment in which your code is deployed.

## Promoting pending changes to production

After making a change to a workflow or brand relating settings, this change will be added under the [changes](https://web.novu.co/changes?utm_campaign=docs-environments) page in the admin panel.

A change is generated by making a difference between the `development` environment and the target `production` environment. All pending changes will be listed on the [changes](https://web.novu.co/changes?utm_campaign=docs-environments) page.

A change can either be applied manually or by pressing the **Promote all changes** button.

<Frame>
  <img />
</Frame>

<br />

<Note> Before pushing a change to production, make sure that the code associated with this change was pushed to production. This is specifically important when adding new variables to a workflow. </Note>

## API Reference Links

* [Get Current Environment API](/api-reference/environments/get-current-environment/)
* [Get API Keys API](/api-reference/environments/get-api-keys/)
* [Regenerate API Keys API](/api-reference/environments/regenerate-api-keys/)


# Inbound Parse Webhook
Source: https://v0.x-docs.novu.co/platform/inbound-parse-webhook

Learn how to process incoming emails for a domain or subdomain

Inbound Webhook is a feature that allows processing of incoming emails for a domain or subdomain.
The feature parses contents of an email and POSTs the information to a specified URL in a `multipart/form-data` format.

<Note>
  This feature is available only in Novu cloud. This feature will not work in community self
  hosted version and local environment.
</Note>

## Steps to set up Inbound Webhook

1. Set up an MX Record:
   * Log in to your domain host's website and navigate to the MX Records page.
   * Create a new MX record for the subdomain you want to process incoming email (e.g. reply.yourdomain.com).
   <Warning>
     You must create a new record for this as this feature does not work if the MX record is already set on the domain.
     Here is an example with [route 53](https://medium.com/@deep_blue_day/how-to-create-a-subdomain-in-amazon-route-53-81918654f5bf)
   </Warning>
   * Assign the MX record a priority of 10 and point it to the specified inbound mail server that located on the admin dashboard on the Email Settings.
     <Info>
       For US, use `inbound-mail.novu.co` and For EU, use
       `eu.inbound-mail.novu.co`
     </Info>
2. Add Domain to allowed list:
   * Log in to the dashboard.
   * Go to the Setting tab in the left vertical navbar.
   * Navigate to Email Settings on the settings page.
   * Add your domain to the allowed domain box.
   <Warning>
     You can only add one Inbound Webhook domain per organization.
   </Warning>
3. Enable Inbound Parse and Set Webhook URL:
   * Log in to the dashboard.
   * Navigate to the Workflow Editor.
   * Select the email step.
   * Enable the Inbound Parse feature.
   * Set the Webhook URL to the location where you want the parsed data to be POSTed.

<Note>The Webhook URL must be publicly accessible without authentication.</Note>


# Webhooks for Providers
Source: https://v0.x-docs.novu.co/platform/webhooks-for-providers

Learn how to setup webhook support for a provider.

Novu provides a URL that you can use to setup webhook support for your integrated provider.

This enables to receive much more detailed information from the provider about the outgoing messages in the [Activity Feed](/activity-feed/introduction) section.

Currently, only `Email` and `SMS` channels are supported with limited providers. Support for more providers will be added in future.

<Note>
  This feature is available only in Novu cloud. This feature will not work in community self
  hosted version and local environment.
</Note>

## Get your Webhook URL

To get your provider specific webhook URL, follow the below steps:

* Open your already connected provider from the `Integration Store` page.
* Scroll down the modal to find the `Webhook URL` field.
* Copy the given URL to configure it on the provider's webhook setup page.

<Frame>
  <img />
</Frame>

<br />

<Note> Webhook URL will only be visible for connected providers and after you've connected the provider. </Note>

## Supported Providers

* [Mailjet](/channels-and-providers/email/mailjet)
* [Mandrill](/channels-and-providers/email/mandrill)
* [Postmark](/channels-and-providers/email/postmark)
* [Sendgrid](/channels-and-providers/email/sendgrid)
* [Sendinblue](/channels-and-providers/email/sendinblue)
* [Telnyx](/channels-and-providers/sms/telnyx)
* [Twilio](/channels-and-providers/sms/twilio)


# .NET
Source: https://v0.x-docs.novu.co/quickstarts/.NET

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with .NET.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications from a .NET app.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-dotnet) if you don’t have one yet.
* A working .NET development environment with a .NET version of .NET Core 2.0+ and .NET Framework of 4.6.1+.

You can also [view the completed code](https://github.com/novuhq/novu-dotnet-quickstart) of this quick start in a GitHub repo.

## Install Novu .NET SDK

The [.NET SDK](https://github.com/novuhq/novu-dotnet) provides a fluent and expressive interface for interacting with Novu's API and managing notifications.

Now install the Novu .NET SDK by running the following command in your terminal:

```bash theme={null}
dotnet add package Novu

```

Otherwise, modify your .csproj file add the following to it:

```xml theme={null}
<ItemGroup>
    <PackageReference Include="Novu" Version="*" />
</ItemGroup>

```

Next, install the SDK by running the following `dotnet` command:

```bash theme={null}
dotnet restore

```

## Initialize & Configure the Novu SDK

Create a new file, `Program.cs` in your application and add the following code to it:

Program.cs:

```csharp theme={null}
using Novu.DTO;
using Novu.DTO.Topics;
using Novu.Models;
using Novu;

 var novuConfiguration = new NovuClientConfiguration
{
    ApiKey = "<NOVU_API_KEY>",
};

var novu = new NovuClient(novuConfiguration);
```

Replace the `ApiKey`’s value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-dotnet) and be sure to use your specific Novu instance URL.

<Note>
  Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-dotnet) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favourite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create A Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **Untitled.** Rename it to a more suitable title.
4. Select **Email** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

6. Click on the “Test” tab and send a test email to verify your workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. Yaaay, you have successfully sent your first notification via the Novu dashboard! Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click “Subscribers” on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```csharp theme={null}
// Create subscriber

var newSubscriberDto = new SubscriberCreateData
{
  SubscriberId = "77809", //replace with system_internal_user_id
  FirstName = "John",
  LastName = "Doe",
  Email = "benlin1994@gmail.com",
  Data = new List<AdditionalDataDto>{
    new AdditionalDataDto
    {
        Key = "External ID",
        Value = "1122334455"
    },
    new AdditionalDataDto
    {
        Key = "Job Title",
        Value = "Software Engineer"
    }
  }
};

var subscriber = await novu.Subscriber.Create(newSubscriberDto);
```

Run the code in your terminal like so:

```bash theme={null}
dotnet run Program.cs

```

You should see the subscriber on your Novu dashboard.

<Frame>
  <img />
</Frame>

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `UpdateSubscriber` method like so:

Program.cs:

```csharp theme={null}
// Update subscriber detail
var subscriber7789 = await novu.Subscriber.GetSubscriber("7789");

subscriber7789.Email = "validemail@gmail.com"; // replace with valid email
subscriber7789.FirstName = "<insert-firstname>"; // optional
subscriber7789.LastName = "<insert-lastname>"; // optional

var updatedSubscriber = await novu.Subscriber.Update("7789",subscriber7789);
```

Other valid fields that can be updated are `phone`, `avatar`, and `data` . The `data` field can accept an array of metadata that you want to attach to the subscriber.

<Note>
  To make all of your app users subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

OnboardEventPayload.cs:

```csharp theme={null}
// OnboardEventPayload.cs
public class OnboardEventPayload
{
  [JsonProperty("username")]
  public string Username { get; set; }

  [JsonProperty("welcomeMessage")]
  public string WelcomeMessage { get; set; }
}

```

Program.cs:

```csharp theme={null}
var onboardingMessage = new OnboardEventPayload
{
  Username = "jdoe",
  WelcomeMessage = "Welcome to novu-dotnet"
};

var payload = new EventCreateData()
{
  EventName = "onboarding", //make sure you have a trigger named "onboarding"
  To = { SubscriberId = "7789" },
  Payload = onboardingMessage
};

var trigger = await novu.Event.Trigger(payload);

if (trigger.Data.Acknowledged)
{
  Console.WriteLine("Trigger has been created.");
}

```

Before running the code, make sure you understand the following:

* The value of `EventName` should be the workflow’s trigger ID/slug(it's the value all in small caps).

<Frame>
  <img />
</Frame>

* The value of `Payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `SubscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriberId.

Run the code to trigger a notification!

```bash theme={null}
dotnet run Program.cs

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safeguards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```csharp theme={null}
// Create Topic
var topicRequest = new TopicCreateData
{
    Key = "frontend-users",
    Name = "All frontend users",

};

var topic = await novu.Topic.Create(topicRequest);
```

Before running the code, make sure you understand the following:

* When creating a `Key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `Name` should be a descriptive topic name.

## Add Subscribers to a Topic

Copy and paste the following code into your app to add subscribers to a topic:

```csharp theme={null}

// Add Subscriber to Topic
var topicKey = "frontend-users";
var subscriberList = new TopicSubscriberUpdateDto
{
    Keys = new List<string>
    {
        "7789",
        "7790",
    }
};

//Or

var subscriberList = new TopicSubscriberCreateData(new List<string>
{
    "7789",
    "7790"
});

var result = await novu.Topic.AddSubscriber(topicKey, subscriberList);
```

## Sending a Notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

Program.cs

```csharp theme={null}
// Send notifications to a topic (all frontend users)

var onboardingMessage = new OnboardEventPayload
{
  WelcomeMessage = "Welcome to novu-dotnet"
};

var payloadTopic = new EventTopicTriggerDto
{
  EventName = "onboarding",
  Payload = onboardingMessage,
  Topic = { Type = "7789", TopicKey = "frontend-users" },

};

var triggerTopic = await novu.Event.TriggerTopicAsync(payloadTopic);

if (triggerTopic.TriggerResponsePayloadDto.Acknowledged);
{
  Console.WriteLine("Trigger has been created.");
}

```

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider and triggered a notification in your application.


# Angular
Source: https://v0.x-docs.novu.co/quickstarts/angular

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Angular.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications and integrate a rich, customizable and ready-to-use real-time UI In-App notification center in Angular apps.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-angluar) if you don’t have one yet
* Angular CLI (Command Line Interface) installed on your machine
* Angular version 15 or higher

You can also [view the completed code](https://github.com/novuhq/angular-quickstart) of this quick start in a GitHub repo.

## Create a new Angular app

To create a new Angular app, open a terminal or command prompt and  run the following command:

```bash theme={null}
ng new my-app
```

Here, `my-app` is the name of your new Angular app.  This command will create a new Angular app with a basic file structure and all the necessary dependencies installed.

Navigate to the app directory by running the following command:

```bash theme={null}
cd my-app
```

Once you are in the app directory, you can start the development server by running the following command:

```bash theme={null}
ng serve
```

This command will start the development server and launch your app in the default browser. You can access your app by navigating to `http://localhost:4200/`.

<Frame>
  <img />
</Frame>

## Install Novu Angular Notification Center Package

The Novu Angular package provides a Angular component wrapper over the web component that you can use to integrate the notification center into your Angular application.

Navigate to the root directory of your Angular application. Now install the Angular Notification Center package by running the following command in your terminal:

<CodeGroup>
  ```bash pnpm theme={null}
  pnpm i @novu/notification-center-angular
  ```

  ```bash npm theme={null}
  npm i @novu/notification-center-angular
  ```

  ```bash yarn theme={null}
  yarn add @novu/notification-center-angular
  ```
</CodeGroup>

## Configuring Application Environments

Using the Angular CLI, start by running the [generate environments command](https://angular.io/cli/generate#environments-command)
shown here to create the `src/environments/`directory and configure the  project to use these files.

```bash theme={null}
ng generate environments
```

Navigate to `my-app/src/environments/environment.ts`  and add the following variables: `subscriberId`, `applicationIdentifier`

* **`applicationIdentifier`** can be found here: [https://web.novu.co/settings](https://web.novu.co/settings)
* **`subscriberId`** can be found here: [https://web.novu.co/subscribers](https://web.novu.co/subscribers)

```tsx theme={null}
export const environment = {
  production: false,
  subscriberId: '',
  applicationIdentifier: '',
};
```

Copy and paste the same code into `my-app/src/environments/environment.development.ts`

These variables are needed for the `GET` request our notification center will make to Novu’s API to push notifications into the feed.

## Adding Novu Module

Now, navigate to the `app.module.ts` file `(my-app/src/app/app.module.ts)`

* Import `CUSTOM_ELEMENTS_SCHEMA` from `'@angular/core'`
* Add Novu’s notification center module

```jsx theme={null}
import { CUSTOM_ELEMENTS_SCHEMA, NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { AppComponent } from './app.component';
import { NotificationCenterModule } from '@novu/notification-center-angular';

@NgModule({
  declarations: [AppComponent],
  imports: [BrowserModule, NotificationCenterModule],
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
  providers: [],
  bootstrap: [AppComponent],
})
export class AppModule {}
```

Head to `my-app/src/app/app.component.ts` file.

⚠️ The `app.component.ts` file is a critical part of an Angular application, as it  defines the root component and provides the foundation for the rest of  the app's functionality.

Now, we are going to import the `environment` variables to make them accessible in the `app.component.html` and the `styles` properties of our notification center

(there are many properties, but you can discover them later on)

```tsx theme={null}
import { Component } from '@angular/core';
import { environment } from '../environments/environment';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css'],
})
export class AppComponent {
  title = 'my-app';

  subscriberId = environment.subscriberId;
  applicationIdentifier = environment.applicationIdentifier;

  styles = {
    bellButton: {
      root: {
        svg: {
          color: 'white',
          width: '45px',
          height: '40px',
          fill: 'white',
        },
      },
      dot: {
        rect: {
          fill: 'rgb(221, 0, 49)',
          strokeWidth: '0.2',
          stroke: 'white',
          width: '3.5px',
          height: '3.5px',
        },
        left: '40%',
      },
    },
    header: {
      root: {
        backgroundColor: '',
        '&:hover': { backgroundColor: '' },
        '.some_class': { color: '' },
      },
    },
    layout: {
      root: {
        backgroundColor: '',
      },
    },
    popover: {
      arrow: {
        backgroundColor: '',
        border: '',
      },
    },
  };

  sessionLoaded = (data: unknown) => {
    console.log('loaded', { data });
  };
}
```

The Angular component is generated as a wrapper around the original React component. This approach is clever, as it allows Novu's engineers to focus on creating and developing things in the React way.

Additionally, many other frameworks can still use the created components using the wrapping approach.

Now head to the `my-app/tsconfig.json` file, we’re going to add `"allowSyntheticDefaultImports": true` to the `compilerOptions` array.

```diff theme={null}
{
  "compilerOptions": {
+   "allowSyntheticDefaultImports": true,
  }
}
```

## Use & Display The Notification Center Component

Open the `my-app/src/app/app.component.html` file.

This file contain the CSS code along with the HTML one - ideally you should separate the CSS to the `my-app/src/app/app.component.css` file, but it’s not mandatory.

We will add our notification center to the .toolbar div.

Paste the following into your `app.component.html` file:

```jsx theme={null}
  <div id="bell-icon">
    <notification-center-component
      [subscriberId]="subscriberId"
      [applicationIdentifier]="applicationIdentifier"
      [sessionLoaded]="sessionLoaded"
      [styles]="styles"
    ></notification-center-component>
  </div>
```

And in the `<style>` tag, we also want to add some margin to our `#bell-icon` so that it looks good next to the other icons.

```css theme={null}
.toolbar #bell-icon {
  height: '';
  margin: 0 16px;
}
```

Run your app again. Now you should see the bell icon (the notification center) in the toolbar section of your app.

You should now see a **bell button** that opens the notification center when clicked. This bell can be customized to your preference.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Note: There are no notifications because none has been triggered yet. When notifications are sent to a subscriber, it will show up in the UI. Next, we'll learn how to trigger notifications.

* [Angular Notification Center Example Repo](https://github.com/novuhq/examples/tree/main/novu-angular-notification-center)

## Create A Workflow

The first step to trigger notifications is to create a workflow. A workflow is like a map that holds the entire flow of messages sent to the subscriber.

The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **“Create Workflow”** button on the top right.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select **"In-App"** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added In-App channel and configure it according to your preferences. Once you’re done, click Update to save your configuration.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).

Feel free to add only text for now and rename the workflow to `Onboarding In App`. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Next, we’ll learn how to create subscribers on Novu - *Recipients of Notifications*

## Create A Subscriber

Click **Subscribers** on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-angluar) to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu.

Novu has a plethora of backend SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin) to choose from to create a subscriber programmatically. This is the recommended method.

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.identify('123', {
  firstName: 'Emil',
  lastName: 'Pearce',
  returnUser: true,
});
```

Obtain your API key from your [Novu dashboard.](https://web.novu.co/settings?utm_campaign=docs-quick-angluar) Replace `<NOVU_API_KEY>` with it.

Now check your Novu dashboard. You should see the recently created subscriber.

You can also update the subscriber info like so:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('123', {
  firstName: 'Emil', // new first name
  lastName: 'Pearce', // new last name
});
```

## Trigger A Notification

To trigger a notification, simply run the code below with the correct credentials.

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.trigger('onboarding-in-app', {
  to: {
    subscriberId: '132',
  },
});
```

`onboarding-in-app` is the workflow identifier we created earlier.

Ensure the `subscriberId` value in the backend code that triggers the notification matches the `subscriberId` in your `my-app/src/environments/environment.ts` code.

```jsx theme={null}
export const environment = {
  production: false,
  subscriberId: '',
  applicationIdentifier: '',
};
```

Check your app again. You should see the recently triggered notification!

## Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, configured a channel provider and triggered a notification in your Angular application.


# General
Source: https://v0.x-docs.novu.co/quickstarts/general

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications.

To create your free managed, or docker-based Novu environment use our CLI tool:

```
npx novu init
```

After creating your cloud or self-hosted account, the next steps to sending your first notification are outlined in this guide:

* Connect your providers
* Create a workflow
* Send a trigger
* Integrate the [Notification Center](https://docs.novu.co/notification-center/getting-started) within your app *(optional)*

# Connect providers

On the **Integration Store** page, you can configure the different providers and their respective credentials. During the alpha phase only a **single provider** is allowed **per channel**, adding a second email provider will de-activate the previously added email provider.

# Create a workflow

After configuring the designated channel provider, you can create your workflow. You can think of the workflow as the blueprint for the notifications that will be sent. The workflow includes:

* Workflow details
* Channel specific content
* Trigger definition

### Workflow Details

The **name** of the workflow is converted to a slug that is used as the trigger identifier which is used when sending the trigger from the back-end.

### Channel specific content

### Email

You can specify the content for emails in two ways:

**Visual workflow builder** - For simple use cases, you can use our visual workflow editor. The visual workflow builder has limited control over design but is easier to get-started with.

**Custom Code** - You can use the custom code section to specify custom html for the email.

You can specify custom variables using the [handlebars](https://handlebarsjs.com/guide/) syntax.

### SMS

Inside SMS, you can specify custom variables using [handlebars](https://handlebarsjs.com/guide/) syntax.

### In-app

In the notification center preview, you can type the content of the notification, select the content, and use `CMD` + `B` to make the selected text bold.

### Chat

You can specify custom variables using the [handlebars](https://handlebarsjs.com/guide/) syntax.

In addition to the integration, any subscriber needs to set credentials to have proper authorization on the channel.

The credentials can be saved through our `@novu/node` package.

# Trigger the workflow

After creating the workflow, Novu generates the trigger. Use the server SDK in your application in the appropriate place for the specific trigger.

```tsx theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<USER_IDENTIFIER>',
    email: 'email@email.com',
    firstName: 'John',
    lastName: 'Doe',
  },
  payload: {
    customVariables: 'Hello',
  },
});
```

The trigger function contains a parameters object as the second parameter. Let's explore its different options:

### `to` key

The `to` parameter contains the information about the subscriber of the notification. You can work with Novu in 2 modes:

### Pass the subscriber information in the trigger (Quickest)

You can pass the subscriber object containing the following keys as this parameter:

```tsx theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
    firstName,
    lastName,
    email,
    phone,
    avatar,
    locale,
  },
  payload: {},
});
```

The `subscriberId` is a custom identifier that identifies users within the Novu platform. We suggest using your internal DB identifier for this field.

When the trigger is called, Novu performs an upsert command, which either creates a subscriber with the specified payload, or updates the existing subscriber with the passed information.

**Note:** The API performs a PATCH command, updating only the fields passed to it. So to reset a specific field, you must explicitly pass `null` as the fields param.

### Pass only the `subscriberId` (Recommended)

```tsx theme={null}
{
  to: 'SUBSCRIBER_ID',
  payload: {}
}
```

In this approach, you only pass the `subscriberId` as part of the trigger, however, this approach requires you to identify the subscriber using the `identify` method from the `@novu/node`library.

### `payload` object

The `payload` object can pass any serializable JSON object to be used in the workflows.


# Go quickstart
Source: https://v0.x-docs.novu.co/quickstarts/go

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Go.

## Go Quickstart

Welcome to Go Quickstart guide for Novu. In this guide, you'll learn how to use Novu in a Go application. Novu is a powerful notification service that enables you to send multi-channel (SMS, Email, Chat, Push) notifications. Let's see how you can seamlessly integrate Novu into your Go project!

## Prerequisites

Before diving into the Quickstart, make sure you have the following:

* The [Go SDK](https://go.dev/doc/install) installed on your development machine.
* A Novu account. If you don't have one, sign up for free [here](https://web.novu.co?utm_campaign=docs-gs-quick-go)

## Install and Set Up Novu in your Go Project

First, you must install the Novu package in your Go project. From your terminal, you can install the Novu package in your project by running the following command:

```bash theme={null}
go get github.com/novuhq/go-novu

```

Once installed, you can import Novu into your project and initialize it using your Novu account credentials. This step establishes a connection between your app and the Novu notification service.

```go theme={null}
import (
 novu "github.com/novuhq/go-novu/lib"
)

novuClient := novu.NewAPIClient("<NOVU_API_KEY>", &novu.Config{})

```

Replace `<NOVU_API_KEY>` with your own API key that you got from the API Key section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-go).

<Note>
  🔑 Note: Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

## Configure retry

```go theme={null}
import (
 novu "github.com/novuhq/go-novu/lib"
)

novuClient := novu.NewAPIClient(apiKey, &novu.Config{RetryConfig: &novu.RetryConfigType{RetryMax: 3, WaitMin: 1 * time.Second, WaitMax: 5 * time.Second, InitialDelay: 0 * time.Second}})

```

| Options      | Detail                                                          | Default Value |
| ------------ | --------------------------------------------------------------- | ------------- |
| RetryMax     | Specifies total number of retries to perform in case of failure | 0             |
| WaitMin      | Specifies the minimum time to wait before retrying              | 0             |
| WaitMax      | Specifies the maximum time to wait before retrying              | 0             |
| InitialDelay | Specifies the initial delay before the first retry attempt      | 0             |

<Info>
  Above retry configuration is applied to all the sdk methods.
</Info>

## Set Up A Channel Provider

A channel provider is a service that lets you use one or more notification channels such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-go) currently supports four channels: Email, SMS, Chat, and Push. Each of these channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel** at a time. Connect anyone of your preferred providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Notification Workflow

A notification workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber.

The workflow includes the following:

* Notification workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be setup for the Chat channel.
</Note>

To create a notification workflow, please follow the following steps:

1. Click **Workflows** on the left sidebar of your Novu dashboard.

2. Click the **Create Workflow** button on the top right.

3. Select **blank workflow** from the dropdown.

4. The name of a new workflow is currently "Untitled." Rename it to a suitable title.

5. Select any channel you want to use in your app. For the sake of this guide, we'll be using the 'Email' channel.
   <Frame>
     <img />
   </Frame>

6. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

7. Click on the “Test” tab and send a test email to verify your notification workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. If you didn't, please check your 'spam' folder as sometimes test emails can end up there. Yaaay, you have successfully sent your first notification via the Novu dashboard!

Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display only one subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)


## Create a subscriber
func main() {
    ctx := context.Background()
    subscriberID := "<REPLACE_WITH_YOUR_SUBSCRIBER>"
    subscriber := novu.SubscriberPayload{
     LastName: "Skjæveland",
     Email:    "benedicte.skjaeveland@example.com",
     Avatar:   "https://randomuser.me/api/portraits/thumb/women/79.jpg",
     Data: map[string]interface{}{
      "location": map[string]interface{}{
       "city":     "Ballangen",
       "state":    "Aust-Agder",
       "country":  "Norway",
       "postcode": "7481",
      },
     },
    }

 resp, err := novuClient.SubscriberApi.Identify(ctx, subscriberID, subscriber)
 if err != nil {
  log.Fatal("Subscriber error: ", err.Error())
  return
 }

 fmt.Println(resp)
}

```

Run the code in your terminal like so:

```bash theme={null}
go run main.go # replace main.go with your file name

```

You should see a new subscriber (that you created above) on your Novu dashboard.

## Update A Subscriber

To update the Subscriber details you can call the put method from SubcriberApi. Here is an example:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Update subscriber details
func main() {
    ctx := context.Background()
    subscriberID := "<REPLACE_WITH_YOUR_SUBSCRIBER>"
    updateSubscriber := novu.SubscriberPayload{FirstName: "Susan"}
 updateResp, err := novuClient.SubscriberApi.Update(ctx, subscriberID, updateSubscriber)
 if err != nil {
  log.Fatal("Update subscriber error: ", err.Error())
  return
 }

 fmt.Println(updateResp)
}

```

<Note>
  Note: To send notifications to all your users, you'll need to make them subscribers in Novu, which you can do by programmatically adding them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Trigger A Notification
func main() {
    subscriberID := "<REPLACE_WITH_YOUR_SUBSCRIBER>"
 apiKey := "<REPLACE_WITH_YOUR_API_KEY>"
 eventId := "<REPLACE_WITH_YOUR_EVENT_ID>"

 ctx := context.Background()
 to := map[string]interface{}{
  "lastName":     "Nwosu",
  "firstName":    "John",
  "subscriberId": subscriberID,
  "email":        "johnnwosu@email.com",
 }
 payload := map[string]interface{}{
  "name": "Hello World",
  "organization": map[string]interface{}{
   "logo": "https://happycorp.com/logo.png",
  },
 }
 
 novuClient := novu.NewAPIClient(apiKey, &novu.Config{})
 triggerResp, err := novuClient.EventApi.Trigger(ctx, eventId, novu.ITriggerPayloadOptions{
  To:      to,
  Payload: payload,
 })
 if err != nil {
  log.Fatal("Novu error", err.Error())
  return
 }

 fmt.Println(triggerResp)
}

```

Before running the code, make sure you understand the following:

* The value of `eventId` should be the notification workflow's trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the notification template content.
* The value of `subscriberId` is the id of the subscriber on Novu.

Replace all items with their respective and accurate values.

Run the code to trigger a notification!

```bash theme={null}
go run main.go # replace main.go with your file name

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Create Topic
func main() {
    ctx := context.Background()
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
    topicName := "<REPLACE_WITH_YOUR_TOPIC_NAME>"
 createResp, err := novuClient.TopicsApi.Create(ctx, topicKey, topicName)
 if err != nil {
  log.Fatal("Create topic error: ", err.Error())
  return
 }

 fmt.Println(createResp)
}

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

## Add subscriber to Topic
func main() {
    ctx := context.Background()
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
    subscribers := []string{"<SUBSCRIBER_ID_1>", "<SUBSCRIBER_ID_2>"}
 addSubscribersResp, err := novuClient.TopicsApi.AddSubscribers(ctx, topicKey, subscribers)
 if err != nil {
  log.Fatal("Add subscriber to topic error: ", err.Error())
  return
 }

 fmt.Println(addSubscribersResp)
}

```

On the other hand, if you want to remove subscribers from a topic, do the following:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

## Remove subscriber from Topic
func main() {
    ctx := context.Background()
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
    subscribers := []string{"<SUBSCRIBER_ID_1>", "<SUBSCRIBER_ID_2>"}
 removeSubscribersResp, err := novuClient.TopicsApi.RemoveSubscribers(ctx, topicKey, subscribers)
 if err != nil {
  log.Fatal("Add subscriber to topic error: ", err.Error())
  return
 }

 fmt.Println(addSubscribersResp)
}

```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Trigger A Notification
func main() {
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
 apiKey := "<REPLACE_WITH_YOUR_API_KEY>"
 eventId := "<REPLACE_WITH_YOUR_EVENT_ID>"
 ctx := context.Background()
 
 to := map[string]interface{}{
  "type":     "Topic",
  "topicKey":    topicKey
 }
 payload := map[string]interface{}{
  "name": "Hello World",
  "organization": map[string]interface{}{
   "logo": "https://happycorp.com/logo.png",
  },
 }
 
 novuClient := novu.NewAPIClient(apiKey, &novu.Config{})
    triggerResp, err := novuClient.EventApi.Trigger(ctx, eventId, novu.ITriggerPayloadOptions{
      To:      to,
      Payload: payload,
     })
 if err != nil {
  log.Fatal("Novu error", err.Error())
  return
 }

 fmt.Println(triggerResp)
}

```

## Next Steps

Great job! If you've reached this point, you should now have successfully created a subscriber, notification workflow, configured a channel provider and triggered a notification in your application.

To learn more about notifications and explore Novu's features and capabilities, check out:

* [Novu Digest Engine](https://docs.novu.co/platform/digest) - Learn how to aggregate multiple trigger events into a single message and deliver it to the subscriber.
* [Novu Go SDK](https://github.com/novuhq/go-novu) - Delve deeper into the SDK and explore a lot of features.
* [Novu Notification Center](/getting-started/introduction) - Learn how to integrate a rich, ready-to-use real-time UI notification center into your app.


# iFrame
Source: https://v0.x-docs.novu.co/quickstarts/iFrame

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with iFrame embed

## Requirements

To follow the steps in this quickstart, you’ll need:

* A Novu account. **[Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-iframe)** if you don’t have one yet.
* Basic knowledge of HTML and JavaScript.

You can also **[view the completed code](https://github.com/novuhq/iframe-quickstart)** of this quick start in a GitHub repo.

## Create a workflow

Before triggering a notification, we need to create a workflow. A workflow is like a blueprint that all the notifications are supposed to follow.

> The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

These are the steps to create a workflow:

1. Click **Workflow** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **“Untitled”**. Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.

<img />

Select the in-app channel.

1. Click on the recently added “In-App” channel and configure it according to your preferences. Once you’re done, click “Update” to save your configuration.

<img />

Configure the in-app node as per your needs.

I’ll briefly explain the function of each label in the image above:

* **1-Preview**: This shows you a glimpse of how each notification item will look in the Notification Center UI.
* **2-Avatar**: If turned on, each notification item will show the avatar of the subscriber.
* **3-Action**: With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds**: This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL**: This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter**: This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber’s online status to send them an email if they were online within the last hour. Read [more about filters](/workflows/notification-workflows).
* **7-Editor**: You can add text that you want to be displayed in each notification item. Additionally, you can specify custom variables using **`{{ }}`**. This means you can inject variables from your code into a notification item’s text via a payload.

In our case, we’ll use the custom variables functionality, as shown below:

<img />

We're gonna use custom variables here.

Feel free to add only text for now and rename the workflow to quickstart. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.
Rename the workflow to 'quickstart'.

<img />

Now, we’ll learn how to create subscribers on Novu - Recipients of Notifications!

## Create a subscriber

If you click “Subscriber” on the left sidebar of the **[Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-iframe)**, you’ll see the subscriber list. By default, there will only be one subscriber as you’re automatically added as a subscriber when you sign up for Novu:

<img />

<Note> One subscriber is automatically created when you sign up. If you don't see the default subscriber, follow [how to create subscriber](/subscribers/subscribers#create-a-subscriber) documentation to learn on how to create one </Note>

Now, let’s create a subscriber on Novu. After creating a subscriber, we’ll trigger a notification to this subscriber. Subscribers are identified by a unique **`subscriberId`**.

With Novu, you can create a subscriber using any of its SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin). The code to create a subscriber in Novu is:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.identify('123', {
  firstName: 'Sumit',
  lastName: 'Saurabh',
});
```

You can get your API key from the Novu dashboard. Replace **`<NOVU_API_KEY>`** with it. Now, if you’ll go to the Novu dashboard, you shall see the subscriber we created above with **`subscriberId`** of **`123`**.

You can also update information about an already existing subscriber using the **`subscriber.update`** method as shown below:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('123', {
  firstName: 'Saurabh', // new first name
  lastName: 'Sumit', // new last name
});
```

## Embed iFrame Notification Center in a your web app

1. Create a simple HTML file, you can call it `index.html`

2. Copy the following code snippet, it contains a basic html structure with some design elements to make things look more pretty

   <Note> Note that we are using fontAwesome library as a stylesheet dependency. </Note>

   ```html theme={null}
   <!DOCTYPE html>
   <html lang="en">

   <head>
       <meta charset="UTF-8">
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css">

       <title>iFrame Quickstart</title>
       <style>
           body {
               font-family: Arial, sans-serif;
               background-color: #f4f4f4;
               margin: 0;
               padding: 0;
               display: flex;
               justify-content: center;
               align-items: top;
               min-height: 100vh;
           }

           .container {
               text-align: center;
               padding: 20px;
               border-radius: 10px;
               background-color: #ffffff;
               box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.1);
           }

           h1 {
               color: #333333;
           }

           p {
               color: #666666;
               line-height: 1.6;
           }

           .fa {
               cursor: pointer;
           }

           .fa:hover {
               color: #0056b3;
           }
       </style>
   </head>

   <body>

       <div class="container">
           <h1>iFrame Notification Center Icon Bell</h1>
           <div id="notification-bell">
               <i class="fa fa-bell fa-2x"></i>
               <span id="unseen-badge"></span>
           </div>
           <p>Click on the notification bell to see the feed</p>
       </div>
       </div>

       <script>
       </script>
   </body>

   </html>
   ```

3. To activate the iFrame, you should include the following code as a script in your html app.

   ```jsx theme={null}
   <script>
     (function(n,o,t,i,f) {
       n[i] = {}; var m = ['init', 'on']; n[i]._c = [];m.forEach(me => n[i][me] = function() {n[i]._c.push([me, arguments])});
       var elt = o.createElement(f); elt.type = "text/javascript"; elt.async = true; elt.src = t;
       var before = o.getElementsByTagName(f)[0]; before.parentNode.insertBefore(elt, before);
     })(window, document, 'https://embed.novu.co/embed.umd.min.js', 'novu', 'script');

     novu.init(
       '<REPLACE_applicationIdentifier>',
       {
         unseenBadgeSelector: '#unseen-badge',
         bellSelector: '#notification-bell',
       },
       {
         subscriberId: '<REPLACE_WITH_subscriberId>',
       }
     );
   </script>
   ```

   You’ll notice two things used above - **`applicationIdentifier`** and **`subscriberID`**.

   An application identifier is a public key used to identify your application. You can get your own application identifier from the **[Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-iframe)**.

   And subscribers are users to which notifications will be sent. They are identified by a **`subscriberID`** which you can also find in the **[Novu subscribers dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-iframe)**.

4. Now open your html application, you should see something like this:

<img />

If you have replaced the `applicationIdentifier` and `subscriberID`, when you will click the bell, you will see the following:

<img />

To learn how to design and modify your iFrame component, feel free to visit the more in-depth [iFrame section](notification-center/client/iframe).

## Trigger a notification

We can trigger a notification by simply clicking on the `Get Snippet` button

<img />

Switch to `Run a Test` option

<img />

Change the `subscriberId` that we have created (`123`)

<img />

Click on `Run Trigger`

<img />

This will take the workflow we created above with the identifier `quickstart` and send a notification to the subscriber with `subscriberId` of `123`.

Now we will open our web application and see a red dot next to the bell icon, this indicate that we have an unseen notification in our feed.

When we will click on it, we will see our notification.

<img />

## Conclusion

Great job! If you’ve reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, triggered a notification and saw it in your web application using iFrame embed.

If you want to learn more about iFrame embed component, please visit [this section](/notification-center/client/iframe) of the documentation.


# Java quickstart
Source: https://v0.x-docs.novu.co/quickstarts/java

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Java.

## Java Quickstart

Learn how to integrate Novu into your Java project on the fly and send notifications across different channels (SMS, Email, Chat, Push).

In this Quickstart, you will learn how to:

* [Install and Set up the Novu Java SDK.](#install-and-set-up-the-novu-java-sdk-in-your-project)
* [Configure a Notification Channel Provider.](#set-up-a-channel-provider)
* [Set up a Notification Workflow.](#create-a-notification-workflow)
* [Create a Subscriber and update a Subscriber's information.](#create-a-subscriber-and-update-a-subscribers-information)
* [Send your first Notification to a Subscriber.](#trigger-a-notification)
* [Send Notifications via Topics.](#topics)

Let's get started! :muscle:

## Requirements

To be able to use this Quickstart, you would need to have the following:

* A Novu account, if you don't have one yet, [sign up](https://web.novu.co?utm_campaign=docs-gs-quick-java) for free.
* A working Java development environment with JDK 17 and Springboot Framework of 3.1.2+.

The completed code for this quick start is available on GitHub. Check it out [here](https://github.com/novuhq/novu-java-quickstart).

## Install and Set up the Novu Java SDK in your project

First, you need to import the library into your application.
If you use Maven, add the dependency to the `pom.xml` file;

```xml theme={null}
<dependency>
  <groupId>co.novu</groupId>
  <artifactId>novu-java</artifactId>
  <version>{use-latest-version}</version>
</dependency>
```

The latest version can be found [on GitHub.](https://github.com/novuhq/novu-java#installation)

If you use Gradle, add the dependency to the `build.gradle` file;

```groovy theme={null}
dependencies {
  implementation 'co.novu:novu-java:{use-latest-version}'
}
```

Sync your project, and you should have the artifacts downloaded.

To use the SDK, you need to have your API key handy, it can be gotten from [settings page](https://web.novu.co/settings?utm_campaign=docs-quick-java) of the web dashboard.

To initialize the library, you can create an instance of `Novu.java` class using any of the following constructors:

```java theme={null}
//Using the API Key only
String apiKey = "INSERT_API_KEY_HERE";
  Novu novu = new Novu(apiKey);
```

```java theme={null}
//Using the API Key plus an instance of NovuConfig
String apiKey = "INSERT_API_KEY_HERE";
  NovuConfig novuConfig = new NovuConfig(apiKey);
  Novu novu = new Novu(novuConfig);
```

Once that is done successfully, head over to the [web dashboard](https://web.novu.co?utm_campaign=docs-quick-java) for the next steps.

## Set up a Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification, etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-java) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favorite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Notification Workflow

A notification workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Notification workflow name and Identifier.
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a notification workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.

<Frame>
  <img />
</Frame>

3. The name of a new notification workflow is currently **Untitled**, rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select **Email** as the channel you want to add, by dragging it from the right sidebar.

<Frame>
  <img />
</Frame>

5. Click on the **Email** in the workflow and edit it as per this image. Don't forget to add the fields in the editor which is supposed to be updated with dynamic values that will be sent when calling the API.
   <Frame>
     <img />
   </Frame>

6. Also, add the variables in the **Variables** section in the test tab and try testing it by sending the email to your email address using the **Send Test Email** button at the bottom right.
   <Frame>
     <img />
   </Frame>

You should get an email within seconds! :ok\_hand:

Great, you have successfully sent your first notification via the Novu dashboard! Now, let's take a step further to trigger notifications via code.

## Create and Update a Subscriber's Information

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);

    SubscriberRequest subscriberRequest = new SubscriberRequest();
        subscriberRequest.setEmail("email");
        subscriberRequest.setFirstName("fName");
        subscriberRequest.setLastName("lName");
        subscriberRequest.setPhone("phone");
        subscriberRequest.setAvatar("avatar");
        subscriberRequest.setSubscriberId("subscriberId");
            try {
                return novu.createSubscriber(subscriberRequest);
            }catch (Exception e){
                log.error("Error Creating Subscriber", e);
            }

            return null;
```

When you run this code snippet, you should see the subscriber on your Novu dashboard.

Now, let's assume you want to modify the email address of the subscriber you just created, you can do that with the following code:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);

    UpdateSubscriberRequest updateSubscriberRequest = new UpdateSubscriberRequest();
        updateSubscriberRequest.setEmail("updatedEmail");
        updateSubscriberRequest.setFirstName("fName");
        updateSubscriberRequest.setLastName("lName");
        updateSubscriberRequest.setPhone("phone");
        updateSubscriberRequest.setAvatar("avatar");

        String subscriberId = "subscriberId";

        try {
            return novu.updateSubscriber(updateSubscriberRequest, subscriberId);
        }catch (Exception e){
            log.error("Error updating Subscriber", e);
        }

        return null;
```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an Object or a Map with the info you want to attach to the subscriber.

<Note>
  To create all of your subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger a Notification

Copy and paste the following code into your app to trigger a notification to a Subscriber:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);

    SubscriberRequest subscriberRequest = new SubscriberRequest();
            subscriberRequest.setSubscriberId("subscriberId");
            subscriberRequest.setEmail("email;");
            subscriberRequest.setFirstName("fName");
            subscriberRequest.setLastName("lName");

    TriggerEventRequest triggerEventRequest = new TriggerEventRequest();
            triggerEventRequest.setName("name");
            triggerEventRequest.setTo(subscriberRequest);
            triggerEventRequest.setPayload(Collections.singletonMap("customVariables", "Hello"));


    try {
        return novu.triggerEvent(triggerEventRequest);
    }catch (Exception e){
        log.error("Error triggering event", e);
    }

            return null;
```

Before running the code, make sure you understand the following:

* The value of `payload` is an array of the data that you want to be dynamically injected into the notification workflow content.
* The value of `subscriberId` is the ID of the subscriber on Novu. Replace `12345` with your subscriber ID.

Run the code to trigger a notification!

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops. A topic is identified by a custom key that is provided by the user, and this key will be the identifier used in the Topics API.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also caters for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```java theme={null}
String apiKey = "API_KEY";
Novu novu = new Novu(apiKey);

TopicRequest createTopicRequest = new TopicRequest();
    createTopicRequest.setKey("key");
    createTopicRequest.setName("name");
        try {
            return novu.createTopic(createTopicRequest);
        }catch (Exception e){
            log.error("Error creating Topic", e);
        }

        return null;
```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add Subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```java theme={null}
String apiKey = "API_KEY";
Novu novu = new Novu(apiKey);

        String topicKey = "key";
        SubscriberAdditionRequest requestBody = new SubscriberAdditionRequest();
        requestBody.setSubscribers(Collections.singletonList("aSubscriberId"));

        try {
            return novu.addSubscriberToTopic(requestBody,topicKey);
        }catch (Exception e){
            log.error("Error Adding Subscriber To Topic", e);
        }

        return null;
```

On the other hand, if you want to remove subscribers from a topic, do the following:

```java theme={null}
String apiKey = "API_KEY";
Novu novu = new Novu(apiKey);


        String topicKey = "key";
        SubscriberAdditionRequest requestBody = new SubscriberAdditionRequest();
        requestBody.setSubscribers(Collections.singletonList("aSubscriberId"));

        try {
            return novu.removeSubscriberFromTopic(requestBody, topicKey);
        }catch (Exception e){
            log.error("Error Removing Subscriber From Topic", e);
        }

        return null;
```

## Send a Notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);


    Topic topic = new Topic();
        topic.setType("Topic");
        topic.setTopicKey("topicKey");

    TriggerEventRequest triggerEventRequest = new TriggerEventRequest();
            triggerEventRequest.setName("name");
            triggerEventRequest.setTo(topic);
            triggerEventRequest.setPayload(Collections.singletonMap("customVariables", "Hello"));


    try {
        return novu.triggerEvent(triggerEventRequest);
    }catch (Exception e){
        log.error("Error sending notification to topic", e);
    }

            return null;
```

## Next Steps

Great job! :clap: If you've reached this point, you should have successfully created a subscriber, notification workflow, configured a channel provider, triggered a single notification, created a topic, added a subscriber to a topic in your application.

To learn more about notifications and explore Novu's features and capabilities, check out:

* [Novu Java SDK](https://github.com/novuhq/novu-java) - Dive deeper into the SDK and explore a lot of features.
* [Novu Digest Engine](/guides/add-digest-to-inapp-notifications) - Learn how to aggregate multiple trigger events into a single message and deliver it to the subscriber.
* [Novu Notification Center](/getting-started/introduction) - Learn how to integrate a rich, ready-to-use real-time UI notification center into your app.


# Kotlin quickstart
Source: https://v0.x-docs.novu.co/quickstarts/kotlin

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Kotlin.

Learn how to integrate Novu into your Kotlin project on the fly and send notifications across different channels (SMS, Email, Chat, Push).

Let's get started! 💪

## Requirements

To be able to use this Quickstart, you would need to have the following:

* A Novu account, if you don't have one yet, [sign up](https://web.novu.co/?utm_campaign=docs-gs-quick-kotlin) for free.
* A working Kotlin project running version 1.6.0+ and Kotlin compiler 1.8.0+.

The completed code for this quick start is available on GitHub. Check it out [here](https://github.com/novuhq/novu-kotlin-quickstart).

## Install and Set up the Novu Kotlin SDK in your project

First, you need to import the library into your application.

If you use Maven, add the dependency to the `pom.xml` file;

```xml theme={null}
<dependency>
  <groupId>co.novu</groupId>
  <artifactId>novu-kotlin</artifactId>
  <version>{use-latest-version}</version>
</dependency>
```

The latest version can be found [on GitHub.](https://github.com/novuhq/novu-kotlin#installation)

If you use Gradle, add the dependency to the `build.gradle` file;

```groovy theme={null}
implementation 'co.novu:novu-kotlin:{use-latest-version}' //Groovy

implementation ("co.novu:novu-kotlin:{use-latest-version}") //Kotlin
```

Sync your project, and you should have the artifacts downloaded.

To use the SDK, you need to have your API key handy, it can be gotten from the [settings page](https://web.novu.co/settings?utm_campaign=docs-quick-kotlin) of the web portal.

To initialize the library, you can create an instance of `Novu.kt` class using any of the following constructors:

```kotlin theme={null}
//Using the API Key only
val novu = Novu(apiKey = "API_KEY")

```

```kotlin theme={null}
//Using the API Key plus an instance of NovuConfig
val novuConfig = NovuConfig(backendUrl = "URL")
val novu = Novu(apiKey = "API_KEY", config = novuConfig)

```

Once that is done successfully, head over to the [web portal](https://web.novu.co/?utm_campaign=docs-quick-kotlin) for the next steps.

## Set up a Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification, etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-kotlin) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favourite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier.
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.

<Frame>
  <img />
</Frame>

3. The name of the new workflow is currently Untitled, rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select Email as the channel you want to add, by dragging it from the right sidebar.

<Frame>
  <img />
</Frame>

5. Click on the Email in the workflow and edit it as per this image. Don’t forget to add the fields in the editor which is supposed to be updated with dynamic values that will be sent when calling the API.

<Frame>
  <img />
</Frame>

6. Also, add the variables in the Variables section in the test tab and try testing it by sending the email to your email address using the Send Test Email button at the bottom right.

<Frame>
  <img />
</Frame>

You should get an email within seconds! 👌

Great, you have successfully sent your first notification via the Novu dashboard! Now, let’s take a step further to trigger notifications via code.

## Create a Subscriber and Update a Subscriber's information

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```kotlin theme={null}
suspend fun createSubscriber(): ResponseWrapper<SubscriberResponse>? {
        val novu = Novu(apiKey = "API_KEY")
        val subscriberRequest = SubscriberRequest(
            email = "email@sample.com",
            firstName = "John",//optional
            lastName = "Doe",//optional
            phone = "123456789",//optional
            avatar = "sample-avatar",//optional
            subscriberId = "12345"//optional
        )
        return CoroutineScope(Dispatchers.IO).async {
            novu.createSubscriber(subscriberRequest)
        }.await()
    }

```

When you run this code snippet, you should see the subscriber on your Novu dashboard. 👤

Now, let's assume you want to modify the email address of the Subscriber you just created, you can do that with the following code:

```kotlin theme={null}
suspend fun updateSubscriber(): ResponseWrapper<SubscriberResponse>? {
        val novu = Novu(apiKey = "API_KEY")
        val subscriberRequest = UpdateSubscriberRequest(
            email = "validemail@sample.com",
            firstName = "John",//optional
            lastName = "Doe",//optional
            phone = "123456789",//optional
            avatar = "sample-avatar"//optional
        )
        val subscriberId = "12345"
        return CoroutineScope(Dispatchers.IO).async {
            novu.updateSubscriber(subscriberId, subscriberRequest)
        }.await()
    }

```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an Object or a Map with the info you want to attach to the subscriber.

<Note>
  To create all of your subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger a Notification

Copy and paste the following code into your app to trigger a notification to a Subscriber:

```kotlin theme={null}
suspend fun triggerNotification(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val triggerEventRequest = TriggerEventRequest(
            name = "test",
            to = SubscriberRequest(
                subscriberId = "12345",
                email = "email@email.com",
                firstName = "John",
                lastName = "Doe"
            ),
            payload = mapOf("customVariables" to "Hello")
        )

        return CoroutineScope(Dispatchers.IO).async {
            novu.trigger(triggerEventRequest)
        }.await()
    }

```

Before running the code, make sure you understand the following:

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the ID of the subscriber on Novu. Replace `12345` with your subscriber ID.

Run the code to trigger a notification! 📧

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops. A topic is identified by a custom key that is provided by the user, and this key will be the identifier used in the Topics API.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also caters for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```kotlin theme={null}
suspend fun createTopic(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val createTopicRequest = CreateTopicRequest(
            key = "key",
            name = "name"
        )
        return CoroutineScope(Dispatchers.IO).async {
            novu.createTopic(createTopicRequest)
        }.await()
    }

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```kotlin theme={null}
suspend fun addSubscriberToTopic(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val topicKey = "key"
        val requestBody = SubscriberList(listOf("name"))
        return CoroutineScope(Dispatchers.IO).async {
            novu.addSubscribers(topicKey, requestBody)
        }.await()
    }

```

On the other hand, if you want to remove subscribers from a topic, do the following:

```kotlin theme={null}
suspend fun removeSubscriberFromTopic(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val topicKey = "key"
        val requestBody = SubscriberList(listOf("name"))
        return CoroutineScope(Dispatchers.IO).async {
            novu.removeSubscriber(topicKey, requestBody)
        }.await()
    }

```

## Sending a Notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```kotlin theme={null}
suspend fun triggerNotificationToTopic(): Any? {
        val novu = Novu(apiKey = "NOVU_API_KEY")
        val triggerEventRequest = TriggerEventRequest(
                name = "test",
                to = listOf(
                        Topic(
                                type = "Topic",
                                topicKey = "posts:comment:12345"
                        )
                ),
                payload = mapOf("customVariables" to "Hello")
        )

        return CoroutineScope(Dispatchers.IO).async {
            novu.trigger(triggerEventRequest)
        }.await()
    }
```

## Conclusion

Great job! 👏
If you've reached this point, you should have successfully created a subscriber, workflow, configured a channel provider, triggered a single notification, created a topic, and added a subscriber to a topic in your application.


# NextJS
Source: https://v0.x-docs.novu.co/quickstarts/nextjs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with NextJS.

This quick start guide is written to help you integrate Novu into your NextJS app in no time. Novu is an open-source notifications infrastructure that you can use in your app to deliver rich notifications across channels like sms, email, in-app, push, chat, etc. In this guide, you’ll learn how to integrate email notifications into your NextJS app.

You can find the code for this app [here](https://github.com/novuhq/nextjs-quickstart/)

## Prerequisites

* Node.js installed on your development machine (to create a NextJS app).
* A Novu account. If you don't have one, sign up for free [here](https://web.novu.co/workflows?utm_campaign=docs-quick-nextjs).

## Create a NextJS app to get started

The first step here would be to create a NextJS app. We will play with Novu in this app later. To get started, open your terminal and create a NextJS app using the following command:

```bash theme={null}
npx create-next-app@latest

```

This will create a NextJS app and now we can add Novu to our project. Open the app using a code editor of your choice. The benefit of using NextJS is that it provides native support for routing, making it effortless to handle navigation and create dynamic pages in your application.

Next.js uses a file-based routing system, where each page in your application is represented by a corresponding file in the `pages` directory.

By creating a new file in the `pages` directory, such as `about.js`, we automatically create a route `/about` in our application. Next.js handles the routing logic behind the scenes, ensuring that when a user accesses `/about`, the corresponding page component is rendered.

In our app, we’ll create a route that will send an email notification to a specified email id. To do this, we need two things:

* Install Novu and connect it to our app
* Create the route and define a function in that route

## Installing Novu and connecting it to the app

To install Novu, simply open your terminal and issue the following command:

```bash theme={null}
npm install @novu/node

```

After installing it, we need to connect our app with our Novu account using the Novu API key. Simply log onto the [Novu web dashboard](https://web.novu.co?utm_campaign=docs-quick-nextjs/) and from the settings there, obtain your API key. We’ll use it to connect our app to our Novu account.

<Frame>
  <img />
</Frame>

Now, we need to connect it to our app. To do so, the first step is to import Novu into our app. Importing Novu will give us the ability to interact with the Novu API. To import Novu into our app, use the following code in a separate file in our app:

```jsx theme={null}
import { Novu } from '@novu/node';

// replace <NOVU_API_KEY> with your actual API key
const novu = new Novu(<NOVU_API_KEY>);
```

Novu lets us send notifications across different channels like email, in-app, chat, SMS, etc, and for each channel, one can use a plethora of providers. You just need to set up a provider for the channel you want to use in Novu:

| Channel | Providers                                                           |   |
| ------- | ------------------------------------------------------------------- | - |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |   |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |   |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |   |
| Push    | FCM, APNS, Expo                                                     |   |

You can see all this in our [integrations store](https://web.novu.co/integrations?utm_campaign=docs-quick-nextjs) and set it up there.

For each channel, there can be only one provider active at a time. Although the exact setup process varies from provider to provider, the general flow is signing up for a provider, getting an API key from its portal, and plugging it into the Novu web portal.

Once having integrated a provider, we need a workflow to send notifications. One can have dynamic data in this workflow if they so choose.

In our case, we’ll have dynamic data and whatever we send as a description will be sent as an email notification. Following are the steps to create a workflow.

## Creating a workflow

1. Click "Workflows” on the left sidebar of your Novu dashboard.
2. Click the “Create Workflow” button on the top right.

<Frame>
  <img />
</Frame>

3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select "Email" as the channel you want to add, by dragging it from the right sidebar:

<Frame>
  <img />
</Frame>

5. Click on the ‘Email’ in the workflow and edit it as per this image. Don’t forget to add the fields in the editor which is supposed to be updated with dynamic values that we’ll send when calling the API.

<Frame>
  <img />
</Frame>

6. Also, add the variables in the ‘variables’ section in the test tab and try testing it by sending the email to your email id using the ‘send test email’ button on the bottom right.

<Frame>
  <img />
</Frame>

Now, we’ve successfully sent the test email and just need to do this from our app.

## Subscribers

In Novu, entities that are supposed to receive notifications are called subscribers. You can see all the subscribers in the ‘subscribers’ tab in the left menu on the Novu web portal. There would be one subscriber by default, which is you. This was created when you signed up for Novu.

In real-world scenarios, the `subscriber id` would be a unique id generated automatically by the database. So for our demo purpose, we’re using a simple subscriber id of ‘1234567890’ in our app.

We’ll first create a subscriber using the following code:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu(<NOVU_API_KEY>);

export async function sendEmail(email, description) {
    await novu.subscribers.identify('1234567890', {
        email: email,
        firstName: "Subscriber",
    });
}

```

Here, we’re creating a subscriber with the subscriber id of `1234567890` and now we’ll send a notification to the subscriber with this very subscriber id by triggering an email notification like follows:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu(<NOVU_API_KEY>);

export async function sendEmail(email, description) {
    await novu.subscribers.identify('1234567890', {
        email: email,
        firstName: "Subscriber",
    });
    await novu.trigger('email-quickstart', {
        to: {
            subscriberId: '1234567890',
            email: email
        },
        payload: {
            email: email,
            description: description
        }
    });
}

```

We’ve exported this function so that we can use this in the route that we’ll now create.

## Create the route and define a function in that route

Now, create a `pages` directory in the root of the project and create a file in it. Give it a name and remember that it will automatically become a route.

In our case, we’re creating a directory called `api` in our pages directory, and inside `api` we’re creating a file called `sub.js`. In this case, our path will be: `http://localhost:3000/api/sub`

In this file, we simply need to define a function that will handle a POST request to our API. It’ll extract the ‘description’ and ‘email’ variables from the ‘request’ body that will be generated every time we make a POST request and call the function to send an email notification with those plugged in.

We’d used these variables in the workflow we had created in the Novu dashboard and also specified the same in the trigger function above.

The function in our route is quite simple and looks like this:

```jsx theme={null}
import { sendEmail } from '@/app/utils/novu';

export default async function subscribe(req, res) {
  try {
    if (req.method === 'POST') {
      const { email, description } = req.body;
      await sendEmail(email, description);
      await res.status(200).json({ message: 'email working' });
    }
  } catch (error) {
    console.log(error);
    res.status(405).json({ message: 'not working' });
  }
}

```

We can now start our local server and test our backend app on Postman. To start the local server, use the following command:

```bash theme={null}
npm run dev

```

Now, open Postman and send a POST request to the route you created earlier. The exact route depends on the file structure you have followed in the pages directory, but in our case, it is - `http://localhost:3000/api/sub`

Also, make sure that in the body, you’re passing the two variables we’re extracting above, namely - email and description, as follows:

<Frame>
  <img />
</Frame>

> In place of [youremail@gmail.com](mailto:youremail@gmail.com), use your actual email and once you send it, you should see the ‘message: email working’ on the bottom as in the image above.

This means that the email notification was sent successfully. Now go to your inbox and you should see an email notification like the following:

<Frame>
  <img />
</Frame>

## Topics

Novu simplifies the process of triggering notifications to multiple subscribers with an API called "Topics". By utilizing the Topics API, you can effortlessly manage bulk notifications easily.

Each topic is uniquely identified by a custom key specified by the user, serving as the primary identifier for interacting with the Topics API.

This intuitive approach streamlines notifications management, empowering users to focus on delivering targeted messages to their subscribers without the hassle of intricate implementation details.

> Make sure that you use a unique key for a Topic. Keys once used, can’t be changed later!

You have the flexibility to assign a descriptive name to a topic. Unlike the topic key, this name does not require uniqueness and can be modified using the provided API.

A topic can have multiple subscribers associated with it. These subscribers will receive notifications whenever a notification is dispatched to the respective topic.

## Create a topic

You can create a topic using two entities - `key` and `name`. Keys are unique identifiers for topics and a name is just something you assign to a topic for convenience.

```jsx theme={null}
import { Novu } from '@novu/node';

export default async function createTopic(req, res) {
  try {
    const novu = new Novu("<NOVU_API_KEY>");
    if (req.method === 'POST') {
      const { key, name } = req.body;
      const result = await novu.topics.create({ key, name });
      res.status(201).json(result.data);
    }
  } catch (error) {
    console.log(error);
    res.status(500).json({ message: error.message });
  }
}

```

This is a simple function that calls the **`create`** method on the **`topics`** property of the \*\*`novu`\*\*instance. This method creates a new topic in the Novu system using the provided **`key`** and **`name`** values.

If you test this on your local machine, you should get something like this:

<Frame>
  <img />
</Frame>

> Note how the return object contains the key I sent from my request body. That signals successful creation!

## Add subscriber to a Topic

The code for adding a subscriber to a previously created topic is as follows:

<Note>
  You can only add those subscribers to a topic that you've already created. You can see all the subscribers in the [Novu web dashboard](https://web.novu.co/subscribers)?utm\_campaign=docs-quick-nextjs
</Note>

```jsx theme={null}
import { Novu } from '@novu/node';

export default async function addSub(req, res) {
  try {
    const novu = new Novu("<NOVU_API_KEY>");
    if (req.method === 'POST') {
      // Get the subscriber ID from the request body
      const subscriberId = req.body.subscriberId;
      // Get the topic key from the request body
      const topicKey = req.body.topicKey;
      // Call Novu SDK to add the subscriber to the topic
      const result = await novu.topics.addSubscribers(topicKey, {
        subscribers: [subscriberId],
      });
      // Return the result as JSON response
      res.status(200).json(result.data);
    }
  } catch (error) {
    console.log(error);
    res.status(500).json({ message: error.message });
  }
}

```

If you see the code above closely, you’ll see that we first establish a connection to Novu using the Novu API key.

Then we extract `subscriberID` and topicKey from the request body and call the **`addSubscribers`** method on the **`topics`** property of the **`novu`** instance, passing the topic key and an object with an array of subscribers.

This adds the subscriber with the `subscriberID` we’d passed to the array of subscribers, which in the above case contains just one subscriber.

If you check this on Postman, the returned array will contain the `subscriberID` that we had passed in the request body, signalling that it was added to the topic successfully.

If, on the other hand, you find the passed `subscriberId` in the `notFound` array inside the `failed` object, it means the subscriber wasn't added to the topic.

You can read more about it [here](https://docs.novu.co/platform/topics/#subscribers-management-in-a-topic).

The image below shows the case where the subscriber has been added successfully:

<Frame>
  <img />
</Frame>

After creating a topic and adding subscribers to the topic, we’ll now proceed to send a notification to all subscribers (we only have one subscriber in our topic though) of a topic. This is what Topics are used for - sending bulk notifications.

## Sending notifications to a topic

Sending notifications to a topic is not a complex task. You need to extract the topic key to which you want to send notifications and trigger Novu’s method on that topic key with the message in the payload:

```jsx theme={null}
import { Novu } from '@novu/node';

export default async function sendNotifToSub(req, res) {
  try {
    const novu = new Novu("<NOVU_API_KEY>");
    if (req.method === 'POST') {
      // Get the topic key from the request body
      const topicKey = req.body.topicKey;
      const email = req.body.email;
      const description = req.body.description;

      // Call Novu SDK to trigger a notification to the topic subscribers
      const result = await novu.trigger('email-quickstart', {
        to: [{ type: 'Topic', topicKey: topicKey }],
        payload: {
          email: email,
          description: description,
        },
      });
      // Return the result as JSON response
      res.json(result.data);
    }
  } catch (error) {
    console.log(error);
    res.status(500).json({ message: error.message });
  }
}

```

Testing this on Postman should give you something like this:

<Frame>
  <img />
</Frame>

If you see this, then it means the notification was sent successfully, as can be seen in my inbox down below:

<Frame>
  <img />
</Frame>

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, and workflow, configured a channel provider, triggered a single notification, and sent an email notification.


# NodeJS quickstart
Source: https://v0.x-docs.novu.co/quickstarts/nodejs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Node.js.

Welcome to the Node.js Quickstart guide for Novu, a powerful notification service that enables you to send multi-channel (SMS, Email, Chat, Push) notifications from your Node.js applications. In this Quickstart, you'll learn how to seamlessly integrate Novu into your app and perform various essential tasks. Let's get started!

## Prerequisites

Before diving into the Quickstart, make sure you have the following:

* Node.js installed on your development machine.
* A Novu account. If you don't have one, sign up for free at [the web dashboard](https://web.novu.co/?utm_campaign=docs-quick-nodejs)

You can also [view the completed code](https://github.com/novuhq/nodejs-sdk-quickstart) of this quick start in a GitHub repo.

## Install and Set Up Novu in your Node.js App

First, you must install the Novu package in your Node.js application. Open your terminal and run the following command:

```bash theme={null}
npm install @novu/node

```

Once installed, you can import Novu into your app and initialize it using your Novu account credentials. This step establishes a connection between your app and the Novu notification service.

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');
```

Replace the `<NOVU_API_KEY>` value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-nodejs).

🔑 Note: Please do not hardcode your credentials in a file in production. Use environment variables instead.

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-nodejs) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favorite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Workflow

A workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Note: Proper authorization needs to be set for the Chat channel for subscribers.

Please proceed to create a workflow.

1. Click “Workflows” on the left sidebar of your Novu dashboard.
2. Click the “Create Workflow” button on the top right.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select "Email" as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

6. Click on the “Test” tab and send a test email to verify your workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. Yaaay, you have successfully sent your first notification via the Novu dashboard! Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click “Subscribers” on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```jsx theme={null}
// Create a subscriber
const subscriberId = '7789'; // Replace this with a unique user ID that matches your database.
await novu.subscribers.identify(subscriberId, {
  email: 'abc@gmail.com', // optional
  firstName: 'John', // optional
  lastName: 'Doe', // optional
  phone: '', // optional
  avatar: '', // optional
  locale: '', // optional
  data: { customKey1: 'customVal1', customKey2: 'customVal2' }, // optional
});
```

Run the code in your terminal like so:

```bash theme={null}
node index.js

```

You should see the subscriber on your Novu dashboard.

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `updateSubscriber` method like so:

```jsx theme={null}
// Update subscriber detail
await novu.subscribers.update('7789', {
  // new email
  email: 'validemail@gmail.com', // optional
  // new phone
  phone: '+19874567832', // optional
});
```

Other valid fields that can be updated are `phone`, `avatar`, and `data` . The `data` field can accept an array of metadata that you want to attach to the subscriber.

Note: To make all of your app users subscribers, you need to programmatically add them to Novu.

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```jsx theme={null}
const notificationWorkflowId = 'first-email';

novu.trigger(notificationWorkflowId, {
  to: {
    subscriberId: '7789',
  },
  payload: {},
});
```

Before running the code, make sure you understand the following:

* The value of `notificationWorkflowId` should be the workflow's trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriber ID.

Run the code to trigger a notification!

```bash theme={null}
node index.js

```

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called "Topics" and allows users to manage their bulk notifications without having to implement complex loops. A topic is identified by a custom key that is provided by the user, and this key will be the identifier used in the Topics API.

⚠️ DANGER: The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.

Users can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed using the API.

A topic can have different subscribers, who will receive a notification whenever a notification is sent to the topic.

## Create a topic

Copy and paste the following code into your app to create a topic:

```jsx theme={null}
const result = await novu.topics.create({
  key: 'unique-topic-identifier',
  name: 'descriptive-topic-name',
});
```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add Subscribers To A Topic

Copy and paste the following code into your app to add subscribers to a topic.

```jsx theme={null}
const topicKey = '<YOUR TOPIC KEY>';

const response = await novu.topics.addSubscribers(topicKey, {
  subscribers: ['subscriber-id-1', 'subscriber-id-2', ...],
});
```

* To add multiple subscribers to a topic, simply separate their names with commas and add them to the array as part of the `subscribers` value.

## Send Notification To A Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, use Novu's API as follows:

```jsx theme={null}
const topicKey = '<TOPIC_KEY>';
const notificationTemplateId = '<WORKFLOW_TRIGGER_IDENTIFIER>';

await novu.trigger(notificationTemplateId, {
  to: [{ type: 'Topic', topicKey: topicKey }],
  payload: {},
});
```

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider, triggered a single notification, created a topic, added a subscriber to a topic and even triggered a notification to a topic in your application.


# Quickstarts
Source: https://v0.x-docs.novu.co/quickstarts/overview

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with any language/framework of your choice.

<CardGroup>
  <Card title="Vue" icon="vuejs" href="/quickstarts/vue">
    Embed a real-time notification center component in your Vue application.
  </Card>

  <Card title="React" icon="react" href="/quickstarts/react">
    Embed a real-time notification center component in your React application.
  </Card>

  <Card title="Angular" icon="angular" href="/quickstarts/angular">
    Embed a real-time notification center component in your Angular application.
  </Card>

  <Card title="VanillaJS" icon="js" href="/quickstarts/vanillajs">
    Embed a real-time notification center component in your VanillaJS
    application.
  </Card>

  <Card
    title="RedwoodJS"
    icon={
  <svg
    xmlns="http://www.w3.org/2000/svg"
    width="25"
    height="23"
    viewBox="0 0 256 277"
  >
    <path
      fill="#FFF"
      d="M112.39 3.928C101.983 9.164 80.046 19.36 68.16 27.493c-11.885 8.134-10.407 15.711-15.61 20.948c-5.203 5.237-20.814 18.329-31.22 26.184c-10.407 7.855-7.806 28.803-10.407 36.658c-2.602 7.855-7.806 26.184-10.407 34.04c-2.602 7.855 5.203 18.329 10.407 28.802c5.203 10.474 18.211 39.277 23.415 49.75c5.203 10.474 20.813 5.237 33.822 15.71c13.009 10.475 31.22 23.568 44.229 31.423c13.008 7.855 18.212 7.855 31.22 0c13.009-7.855 31.22-20.948 44.23-31.422c13.008-10.474 28.618-5.237 33.822-15.71c5.203-10.474 18.211-39.277 23.415-49.75c5.203-10.474 13.008-20.948 10.406-28.803c-2.602-7.856-7.804-26.185-10.406-34.04c-2.602-7.855 0-28.803-10.407-36.658s-22.487-17.857-31.22-26.184c-8.734-8.327-5.204-13.092-15.61-20.948c-10.407-7.855-33.823-18.329-44.23-23.565c-10.406-5.237-20.813-5.237-31.22 0Z"
    />
    <path
      fill="#BF4722"
      d="m75.644 49.319l48.694 33.238a6.886 6.886 0 0 0 3.7 1.155a6.665 6.665 0 0 0 3.7-1.155l48.73-33.35a6.65 6.65 0 0 0 2.748-5.947a6.633 6.633 0 0 0-3.672-5.418L130.85 13.733a6.692 6.692 0 0 0-5.846 0l-48.546 24.11a6.633 6.633 0 0 0-3.707 5.5a6.649 6.649 0 0 0 2.893 5.976Zm68.933 43.671a6.721 6.721 0 0 0 2.886 5.515l39.037 26.68a6.55 6.55 0 0 0 8.103-.522l32.746-29.288a6.654 6.654 0 0 0 2.213-5.156a6.648 6.648 0 0 0-2.509-5.017L195.787 60.2a6.623 6.623 0 0 0-7.844-.298l-40.48 27.686a6.72 6.72 0 0 0-2.886 5.403Zm-97.09 36.293a6.696 6.696 0 0 1 2.182 5.627a6.524 6.524 0 0 1-3.293 5.068l-23.31 13.973a6.586 6.586 0 0 1-7.5-.512a6.698 6.698 0 0 1-2.195-7.238l8.621-27.127a6.607 6.607 0 0 1 4.551-4.397a6.406 6.406 0 0 1 6.143 1.453l14.8 13.153Zm126.432 2.832l-42.144-28.84a6.622 6.622 0 0 0-7.4 0l-42.145 28.84a6.754 6.754 0 0 0-2.886 5.068a6.88 6.88 0 0 0 2.22 5.44l42.108 37.672a6.597 6.597 0 0 0 4.403 1.677a6.63 6.63 0 0 0 4.403-1.677l42.107-37.672a6.73 6.73 0 0 0 2.183-5.44a6.606 6.606 0 0 0-2.849-5.068Zm-112.41-7.452L28.802 95.375a6.804 6.804 0 0 1-2.22-5.254a6.574 6.574 0 0 1 2.478-5.03l31.266-25.152a6.696 6.696 0 0 1 7.882-.298l40.442 27.685a6.682 6.682 0 0 1 3.01 5.59a6.682 6.682 0 0 1-3.01 5.589l-39 26.68a6.624 6.624 0 0 1-8.14-.522Zm167.95 42.069l-33.302-19.935a6.55 6.55 0 0 0-7.77.745l-40.702 36.33a6.696 6.696 0 0 0-2.13 6.13a6.66 6.66 0 0 0 4.055 5.05l56.463 22.878a6.333 6.333 0 0 0 2.442.485c2.621.008 5-1.54 6.069-3.95l17.501-39.2c1.425-3.102.29-6.787-2.627-8.533Zm4.624-47.658l8.622 27.127h-.074a6.71 6.71 0 0 1-.975 5.958a6.61 6.61 0 0 1-5.353 2.724a6.478 6.478 0 0 1-3.367-.932l-23.348-13.973a6.489 6.489 0 0 1-3.182-5.068a6.62 6.62 0 0 1 2.183-5.627l14.8-13.19a6.59 6.59 0 0 1 6.143-1.454a6.72 6.72 0 0 1 4.551 4.435Zm-123.51 70.91a6.66 6.66 0 0 0-2.109-6.111l-40.701-36.331a6.55 6.55 0 0 0-7.77-.745L26.69 166.732c-2.883 1.754-4.024 5.392-2.664 8.496l17.539 39.2c1.453 3.268 5.21 4.798 8.51 3.465l56.427-22.88a6.659 6.659 0 0 0 4.07-5.03Zm19.98 11.178l45.29 18.333a6.665 6.665 0 0 1 3.997 5.44a6.614 6.614 0 0 1-2.813 6.223l-45.326 31.488a6.551 6.551 0 0 1-3.7 1.191a6.682 6.682 0 0 1-3.7-1.191l-45.29-31.488a6.651 6.651 0 0 1-2.849-6.222a6.775 6.775 0 0 1 4.144-5.44l45.29-18.334a6.69 6.69 0 0 1 4.958 0Z"
    />
  </svg>
}
    href="/quickstarts/redwoodjs"
  >
    Embed a real-time notification center component in your RedwoodJS
    application.
  </Card>

  <Card title="iFrame" icon="html5" href="/quickstarts/iFrame">
    Embed a real-time notification center component in your iFrame application.
  </Card>

  <Card title="Node.js" icon="node" href="/quickstarts/nodejs">
    Connect a Node.js application to Novu.
  </Card>

  <Card
    title="PHP"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#deviconPhp0)" d="M0 64c0 18.593 28.654 33.667 64 33.667c35.346 0 64-15.074 64-33.667c0-18.593-28.655-33.667-64-33.667C28.654 30.333 0 45.407 0 64Z"/><path fill="#777bb3" d="M64 95.167c33.965 0 61.5-13.955 61.5-31.167c0-17.214-27.535-31.167-61.5-31.167S2.5 46.786 2.5 64c0 17.212 27.535 31.167 61.5 31.167Z"/><path d="M34.772 67.864c2.793 0 4.877-.515 6.196-1.53c1.306-1.006 2.207-2.747 2.68-5.175c.44-2.27.272-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.464l-2.473 12.732zM20.173 83.547a.694.694 0 0 1-.68-.828l6.557-33.738a.695.695 0 0 1 .68-.561h14.134c4.442 0 7.748 1.206 9.827 3.585c2.088 2.39 2.734 5.734 1.917 9.935c-.333 1.711-.905 3.3-1.7 4.724a15.818 15.818 0 0 1-3.128 3.92c-1.531 1.432-3.264 2.472-5.147 3.083c-1.852.604-4.232.91-7.07.91h-5.724l-1.634 8.408a.695.695 0 0 1-.682.562z"/><path fill="#fff" d="M34.19 55.826h3.891c3.107 0 4.186.682 4.553 1.089c.607.674.723 2.097.331 4.112c-.439 2.257-1.253 3.858-2.42 4.756c-1.194.92-3.138 1.386-5.773 1.386h-2.786l2.205-11.342zm6.674-8.1H26.731a1.39 1.39 0 0 0-1.364 1.123L18.81 82.588a1.39 1.39 0 0 0 1.363 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.151c2.912 0 5.364-.318 7.287-.944c1.977-.642 3.796-1.731 5.406-3.237a16.522 16.522 0 0 0 3.259-4.087c.831-1.487 1.429-3.147 1.775-4.931c.86-4.423.161-7.964-2.076-10.524c-2.216-2.537-5.698-3.823-10.349-3.823zM30.301 68.557h4.471c2.963 0 5.17-.557 6.62-1.675c1.451-1.116 2.428-2.98 2.938-5.591c.485-2.508.264-4.277-.665-5.308c-.931-1.03-2.791-1.546-5.584-1.546h-5.036l-2.743 14.12m10.563-19.445c4.252 0 7.353 1.117 9.303 3.348c1.95 2.232 2.536 5.347 1.76 9.346c-.322 1.648-.863 3.154-1.625 4.518c-.764 1.366-1.76 2.614-2.991 3.747c-1.468 1.373-3.097 2.352-4.892 2.935c-1.794.584-4.08.875-6.857.875h-6.296l-1.743 8.97h-7.35l6.558-33.739h14.133"/><path d="M69.459 74.577a.694.694 0 0 1-.682-.827l2.9-14.928c.277-1.42.209-2.438-.19-2.87c-.245-.263-.979-.704-3.15-.704h-5.256l-3.646 18.768a.695.695 0 0 1-.683.56h-7.29a.695.695 0 0 1-.683-.826l6.558-33.739a.695.695 0 0 1 .682-.561h7.29a.695.695 0 0 1 .683.826L64.41 48.42h5.653c4.307 0 7.227.758 8.928 2.321c1.733 1.593 2.275 4.14 1.608 7.573l-3.051 15.702a.695.695 0 0 1-.682.56h-7.407z"/><path fill="#fff" d="M65.31 38.755h-7.291a1.39 1.39 0 0 0-1.364 1.124l-6.557 33.738a1.39 1.39 0 0 0 1.363 1.654h7.291a1.39 1.39 0 0 0 1.364-1.124l3.537-18.205h4.682c2.168 0 2.624.463 2.641.484c.132.14.305.795.019 2.264l-2.9 14.927a1.39 1.39 0 0 0 1.364 1.654h7.408a1.39 1.39 0 0 0 1.363-1.124l3.051-15.7c.715-3.686.103-6.45-1.82-8.217c-1.836-1.686-4.91-2.505-9.398-2.505h-4.81l1.421-7.315a1.39 1.39 0 0 0-1.364-1.655zm0 1.39l-1.743 8.968h6.496c4.087 0 6.907.714 8.457 2.14c1.553 1.426 2.017 3.735 1.398 6.93l-3.052 15.699h-7.407l2.901-14.928c.33-1.698.208-2.856-.365-3.474c-.573-.617-1.793-.926-3.658-.926h-5.829l-3.756 19.327H51.46l6.558-33.739h7.292z"/><path d="M92.136 67.864c2.793 0 4.878-.515 6.198-1.53c1.304-1.006 2.206-2.747 2.679-5.175c.44-2.27.273-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.463l-2.475 12.732zM77.54 83.547a.694.694 0 0 1-.682-.828l6.557-33.738a.695.695 0 0 1 .682-.561H98.23c4.442 0 7.748 1.206 9.826 3.585c2.089 2.39 2.734 5.734 1.917 9.935a15.878 15.878 0 0 1-1.699 4.724a15.838 15.838 0 0 1-3.128 3.92c-1.53 1.432-3.265 2.472-5.147 3.083c-1.852.604-4.232.91-7.071.91h-5.723l-1.633 8.408a.695.695 0 0 1-.683.562z"/><path fill="#fff" d="M91.555 55.826h3.891c3.107 0 4.186.682 4.552 1.089c.61.674.724 2.097.333 4.112c-.44 2.257-1.254 3.858-2.421 4.756c-1.195.92-3.139 1.386-5.773 1.386h-2.786l2.204-11.342zm6.674-8.1H84.096a1.39 1.39 0 0 0-1.363 1.123l-6.558 33.739a1.39 1.39 0 0 0 1.364 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.15c2.911 0 5.364-.318 7.286-.944c1.978-.642 3.797-1.731 5.408-3.238a16.52 16.52 0 0 0 3.258-4.086c.832-1.487 1.428-3.147 1.775-4.931c.86-4.423.162-7.964-2.076-10.524c-2.216-2.537-5.697-3.823-10.35-3.823zM87.666 68.557h4.47c2.964 0 5.17-.557 6.622-1.675c1.45-1.116 2.428-2.98 2.936-5.591c.487-2.508.266-4.277-.665-5.308c-.93-1.03-2.791-1.546-5.583-1.546h-5.035Zm10.563-19.445c4.251 0 7.354 1.117 9.303 3.348c1.95 2.232 2.537 5.347 1.759 9.346c-.32 1.648-.862 3.154-1.624 4.518c-.763 1.366-1.76 2.614-2.992 3.747c-1.467 1.373-3.097 2.352-4.892 2.935c-1.793.584-4.078.875-6.856.875h-6.295l-1.745 8.97h-7.35l6.558-33.739h14.133"/><defs><radialGradient id="deviconPhp0" cx="0" cy="0" r="1" gradientTransform="translate(38.426 42.169) scale(84.04136)" gradientUnits="userSpaceOnUse"><stop stopColor="#AEB2D5"/><stop offset=".3" stopColor="#AEB2D5"/><stop offset=".75" stopColor="#484C89"/><stop offset="1" stopColor="#484C89"/></radialGradient></defs></svg>
}
    href="/quickstarts/php"
  >
    Connect a PHP application to Novu.
  </Card>

  <Card
    title="Python"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="34.87" viewBox="0 0 256 255"><defs><linearGradient id="logosPython0" x1="12.959%" x2="79.639%" y1="12.039%" y2="78.201%"><stop offset="0%" stopColor="#387EB8"/><stop offset="100%" stopColor="#366994"/></linearGradient><linearGradient id="logosPython1" x1="19.128%" x2="90.742%" y1="20.579%" y2="88.429%"><stop offset="0%" stopColor="#FFE052"/><stop offset="100%" stopColor="#FFC331"/></linearGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosPython0)" d="M126.916.072c-64.832 0-60.784 28.115-60.784 28.115l.072 29.128h61.868v8.745H41.631S.145 61.355.145 126.77c0 65.417 36.21 63.097 36.21 63.097h21.61v-30.356s-1.165-36.21 35.632-36.21h61.362s34.475.557 34.475-33.319V33.97S194.67.072 126.916.072ZM92.802 19.66a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.13Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosPython1)" d="M128.757 254.126c64.832 0 60.784-28.115 60.784-28.115l-.072-29.127H127.6v-8.745h86.441s41.486 4.705 41.486-60.712c0-65.416-36.21-63.096-36.21-63.096h-21.61v30.355s1.165 36.21-35.632 36.21h-61.362s-34.475-.557-34.475 33.32v56.013s-5.235 33.897 62.518 33.897Zm34.114-19.586a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.131a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13Z"/></svg>
}
    href="/quickstarts/python"
  >
    Connect a Python application to Novu.
  </Card>

  <Card
    title="Kotlin"
    icon={
  <svg
    xmlns="http://www.w3.org/2000/svg"
    width="20"
    height="20"
    viewBox="0 0 256 256"
  >
    <defs>
      <linearGradient
        id="logosKotlinIcon0"
        x1="99.991%"
        x2=".01%"
        y1="-.011%"
        y2="100.01%"
      >
        <stop offset=".344%" stopColor="#E44857" />
        <stop offset="46.89%" stopColor="#C711E1" />
        <stop offset="100%" stopColor="#7F52FF" />
      </linearGradient>
    </defs>
    <path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosKotlinIcon0)" d="M256 256H0V0h256L128 127.949z" />
  </svg>
}
    href="/quickstarts/kotlin"
  >
    Connect a Kotlin application to Novu.
  </Card>

  <Card
    title="Ruby"
    icon={
  <svg xmlns="http://www.w3.org/2000/svg" width="20" height="19.93" viewBox="0 0 256 255"><defs><linearGradient id="logosRuby0" x1="84.75%" x2="58.254%" y1="111.399%" y2="64.584%"><stop offset="0%" stopColor="#FB7655"/><stop offset="0%" stopColor="#FB7655"/><stop offset="41%" stopColor="#E42B1E"/><stop offset="99%" stopColor="#900"/><stop offset="100%" stopColor="#900"/></linearGradient><linearGradient id="logosRuby1" x1="116.651%" x2="1.746%" y1="60.89%" y2="19.288%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby2" x1="75.774%" x2="38.978%" y1="219.327%" y2="7.829%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby3" x1="50.012%" x2="66.483%" y1="7.234%" y2="79.135%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E57252"/><stop offset="46%" stopColor="#DE3B20"/><stop offset="99%" stopColor="#A60003"/><stop offset="100%" stopColor="#A60003"/></linearGradient><linearGradient id="logosRuby4" x1="46.174%" x2="49.932%" y1="16.348%" y2="83.047%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E4714E"/><stop offset="56%" stopColor="#BE1A0D"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby5" x1="36.965%" x2="49.528%" y1="15.594%" y2="92.478%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="18%" stopColor="#E46342"/><stop offset="40%" stopColor="#C82410"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby6" x1="13.609%" x2="85.764%" y1="58.346%" y2="-46.717%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="54%" stopColor="#C81F11"/><stop offset="99%" stopColor="#BF0905"/><stop offset="100%" stopColor="#BF0905"/></linearGradient><linearGradient id="logosRuby7" x1="27.624%" x2="50.745%" y1="21.135%" y2="79.056%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="31%" stopColor="#DE4024"/><stop offset="99%" stopColor="#BF190B"/><stop offset="100%" stopColor="#BF190B"/></linearGradient><linearGradient id="logosRuby8" x1="-20.667%" x2="104.242%" y1="122.282%" y2="-6.342%"><stop offset="0%" stopColor="#BD0012"/><stop offset="0%" stopColor="#BD0012"/><stop offset="7%" stopColor="#FFF"/><stop offset="17%" stopColor="#FFF"/><stop offset="27%" stopColor="#C82F1C"/><stop offset="33%" stopColor="#820C01"/><stop offset="46%" stopColor="#A31601"/><stop offset="72%" stopColor="#B31301"/><stop offset="99%" stopColor="#E82609"/><stop offset="100%" stopColor="#E82609"/></linearGradient><linearGradient id="logosRuby9" x1="58.792%" x2="11.964%" y1="65.205%" y2="50.128%"><stop offset="0%" stopColor="#8C0C01"/><stop offset="0%" stopColor="#8C0C01"/><stop offset="54%" stopColor="#990C00"/><stop offset="99%" stopColor="#A80D0E"/><stop offset="100%" stopColor="#A80D0E"/></linearGradient><linearGradient id="logosRubya" x1="79.319%" x2="23.088%" y1="62.754%" y2="17.888%"><stop offset="0%" stopColor="#7E110B"/><stop offset="0%" stopColor="#7E110B"/><stop offset="99%" stopColor="#9E0C00"/><stop offset="100%" stopColor="#9E0C00"/></linearGradient><linearGradient id="logosRubyb" x1="92.88%" x2="59.841%" y1="74.122%" y2="39.704%"><stop offset="0%" stopColor="#79130D"/><stop offset="0%" stopColor="#79130D"/><stop offset="99%" stopColor="#9E120B"/><stop offset="100%" stopColor="#9E120B"/></linearGradient><linearGradient id="logosRubyc" x1="56.57%" x2="3.105%" y1="101.717%" y2="11.993%"><stop offset="0%" stopColor="#8B2114"/><stop offset="0%" stopColor="#8B2114"/><stop offset="43%" stopColor="#9E100A"/><stop offset="99%" stopColor="#B3100C"/><stop offset="100%" stopColor="#B3100C"/></linearGradient><linearGradient id="logosRubyd" x1="30.87%" x2="92.471%" y1="35.599%" y2="100.694%"><stop offset="0%" stopColor="#B31000"/><stop offset="0%" stopColor="#B31000"/><stop offset="44%" stopColor="#910F08"/><stop offset="99%" stopColor="#791C12"/><stop offset="100%" stopColor="#791C12"/></linearGradient><radialGradient id="logosRubye" cx="32.001%" cy="40.21%" r="69.573%" fx="32.001%" fy="40.21%"><stop offset="0%" stopColor="#A80D00"/><stop offset="0%" stopColor="#A80D00"/><stop offset="99%" stopColor="#7E0E08"/><stop offset="100%" stopColor="#7E0E08"/></radialGradient><radialGradient id="logosRubyf" cx="13.549%" cy="40.86%" r="88.386%" fx="13.549%" fy="40.86%"><stop offset="0%" stopColor="#A30C00"/><stop offset="0%" stopColor="#A30C00"/><stop offset="99%" stopColor="#800E08"/><stop offset="100%" stopColor="#800E08"/></radialGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby0)" d="m197.467 167.764l-145.52 86.41l188.422-12.787L254.88 51.393l-57.414 116.37Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby1)" d="M240.677 241.257L224.482 129.48l-44.113 58.25l60.308 53.528Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby2)" d="m240.896 241.257l-118.646-9.313l-69.674 21.986l188.32-12.673Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby3)" d="m52.744 253.955l29.64-97.1L17.16 170.8l35.583 83.154Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby4)" d="M180.358 188.05L153.085 81.226l-78.047 73.16l105.32 33.666Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby5)" d="m248.693 82.73l-73.777-60.256l-20.544 66.418l94.321-6.162Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby6)" d="M214.191.99L170.8 24.97L143.424.669l70.767.322Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby7)" d="m0 203.372l18.177-33.151l-14.704-39.494L0 203.372Z"/><path fill="#FFF" d="m2.496 129.48l14.794 41.963l64.283-14.422l73.39-68.207l20.712-65.787L143.063 0L87.618 20.75c-17.469 16.248-51.366 48.396-52.588 49c-1.21.618-22.384 40.639-32.534 59.73Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby8)" d="M54.442 54.094c37.86-37.538 86.667-59.716 105.397-40.818c18.72 18.898-1.132 64.823-38.992 102.349c-37.86 37.525-86.062 60.925-104.78 42.027c-18.73-18.885.515-66.032 38.375-103.558Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby9)" d="m52.744 253.916l29.408-97.409l97.665 31.376c-35.312 33.113-74.587 61.106-127.073 66.033Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubya)" d="m155.092 88.622l25.073 99.313c29.498-31.016 55.972-64.36 68.938-105.603l-94.01 6.29Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyb)" d="M248.847 82.833c10.035-30.282 12.35-73.725-34.966-81.791l-38.825 21.445l73.791 60.346Z"/><path fill="#9E1209" d="M0 202.935c1.39 49.979 37.448 50.724 52.808 51.162l-35.48-82.86L0 202.935Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubye)" d="M155.232 88.777c22.667 13.932 68.35 41.912 69.276 42.426c1.44.81 19.695-30.784 23.838-48.64l-93.114 6.214Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyf)" d="m82.113 156.507l39.313 75.848c23.246-12.607 41.45-27.967 58.121-44.42l-97.434-31.428Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyc)" d="m17.174 171.34l-5.57 66.328c10.51 14.357 24.97 15.605 40.136 14.486c-10.973-27.311-32.894-81.92-34.566-80.814Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyd)" d="m174.826 22.654l78.1 10.96c-4.169-17.662-16.969-29.06-38.787-32.623l-39.313 21.663Z"/></svg>

}
    href="/quickstarts/ruby"
  >
    Connect a Ruby application to Novu.
  </Card>

  <Card
    title=".NET"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 256 256"><g fill="none"><rect width="256" height="256" fill="#512BD4" rx="60"/><path fill="#fff" d="M24.052 168.943c-2.236 0-4.138-.731-5.703-2.194c-1.566-1.501-2.349-3.283-2.349-5.347c0-2.101.783-3.902 2.349-5.403c1.565-1.5 3.466-2.251 5.703-2.251c2.274 0 4.194.751 5.76 2.251c1.603 1.501 2.404 3.302 2.404 5.403c0 2.064-.801 3.846-2.404 5.347c-1.566 1.463-3.486 2.194-5.76 2.194Zm89.415-1.238H98.929l-38.304-59.318a26.371 26.371 0 0 1-2.404-4.672h-.336c.298 1.726.447 5.422.447 11.087v52.903H45.471V87H60.96l37.018 57.912c1.566 2.402 2.572 4.052 3.02 4.953h.223c-.372-2.139-.559-5.759-.559-10.863V87h12.805v80.705Zm62.631 0h-45.014V87h43.225v11.369h-29.916v22.849h27.568v11.312h-27.568v23.863h31.705v11.312Zm63.973-69.336h-23.038v69.336h-13.309V98.369h-22.982V87h59.329v11.369Z"/></g></svg>
}
    href="/quickstarts/.NET"
  >
    Connect a .NET application to Novu.
  </Card>

  <Card
    title="NextJS"
    icon={
  <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 128 128"><path d="M64 0C28.7 0 0 28.7 0 64s28.7 64 64 64c11.2 0 21.7-2.9 30.8-7.9L48.4 55.3v36.6h-6.8V41.8h6.8l50.5 75.8C116.4 106.2 128 86.5 128 64c0-35.3-28.7-64-64-64zm22.1 84.6l-7.5-11.3V41.8h7.5v42.8z"/></svg>
}
    href="/quickstarts/nextjs"
  >
    Connect a NextJS application to Novu.
  </Card>

  <Card title="Go" icon="golang" href="/quickstarts/go">
    Connect a Go application to Novu.
  </Card>

  <Card
    title="Java"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="#0074BD" d="M47.617 98.12s-4.767 2.774 3.397 3.71c9.892 1.13 14.947.968 25.845-1.092c0 0 2.871 1.795 6.873 3.351c-24.439 10.47-55.308-.607-36.115-5.969zm-2.988-13.665s-5.348 3.959 2.823 4.805c10.567 1.091 18.91 1.18 33.354-1.6c0 0 1.993 2.025 5.132 3.131c-29.542 8.64-62.446.68-41.309-6.336z"/><path fill="#EA2D2E" d="M69.802 61.271c6.025 6.935-1.58 13.17-1.58 13.17s15.289-7.891 8.269-17.777c-6.559-9.215-11.587-13.792 15.635-29.58c0 .001-42.731 10.67-22.324 34.187z"/><path fill="#0074BD" d="M102.123 108.229s3.529 2.91-3.888 5.159c-14.102 4.272-58.706 5.56-71.094.171c-4.451-1.938 3.899-4.625 6.526-5.192c2.739-.593 4.303-.485 4.303-.485c-4.953-3.487-32.013 6.85-13.743 9.815c49.821 8.076 90.817-3.637 77.896-9.468zM49.912 70.294s-22.686 5.389-8.033 7.348c6.188.828 18.518.638 30.011-.326c9.39-.789 18.813-2.474 18.813-2.474s-3.308 1.419-5.704 3.053c-23.042 6.061-67.544 3.238-54.731-2.958c10.832-5.239 19.644-4.643 19.644-4.643zm40.697 22.747c23.421-12.167 12.591-23.86 5.032-22.285c-1.848.385-2.677.72-2.677.72s.688-1.079 2-1.543c14.953-5.255 26.451 15.503-4.823 23.725c0-.002.359-.327.468-.617z"/><path fill="#EA2D2E" d="M76.491 1.587S89.459 14.563 64.188 34.51c-20.266 16.006-4.621 25.13-.007 35.559c-11.831-10.673-20.509-20.07-14.688-28.815C58.041 28.42 81.722 22.195 76.491 1.587z"/><path fill="#0074BD" d="M52.214 126.021c22.476 1.437 57-.8 57.817-11.436c0 0-1.571 4.032-18.577 7.231c-19.186 3.612-42.854 3.191-56.887.874c0 .001 2.875 2.381 17.647 3.331z"/></svg>
}
    href="/quickstarts/java"
  >
    Connect a Java application to Novu.
  </Card>
</CardGroup>


# PHP quickstart
Source: https://v0.x-docs.novu.co/quickstarts/php

Use Novu to send multi-channel (SMS, Email, Chat, Push) notifications from a PHP app.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications from a PHP app.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-php) if you don’t have one yet.
* A working PHP development environment with a PHP version of 7.2+.

You can also [v](https://cloudinary.com/documentation/php_quickstart#view_the_completed_code)[iew the completed code](https://github.com/novuhq/novu-php-quickstart) of this quick start in a GitHub repo.

## Install Novu PHP SDK

The [PHP SDK](http://github.com/novuhq/novu-php) provides a fluent and expressive interface for interacting with Novu's API and managing notifications.

Now install the Novu PHP SDK by running the following command in your terminal:

```bash theme={null}
composer require unicodeveloper/novu

```

Otherwise, create a file named `composer.json` and add the following to it:

```php theme={null}
{
    "require": {
        "unicodeveloper/novu": "^1.0"
    }
}

```

Next, install the SDK by running the following `composer` command:

```bash theme={null}
composer install

```

## Initialize & Configure the Novu SDK

Create a new file, `index.php` in your application and add the following code to it:

```php theme={null}
<?php

  require('vendor/autoload.php');

  use Novu\SDK\Novu;

$apiKey = '<NOVU_API_KEY>';
$novu = new Novu($apiKey);
```

Replace the `$apiKey`’s value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-php).

<Note>
  Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-php) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favourite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create A Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **Untitled.** Rename it to a more suitable title.
4. Select **Email** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

6. Click on the “Test” tab and send a test email to verify your workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. Yaaay, you have successfully sent your first notification via the Novu dashboard! Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click “Subscribers” on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```php theme={null}
// Create subscriber
$novu->createSubscriber([
    'subscriberId' => '7789', // replace with system_internal_user_id
    'email' => 'abc@gmail.com',
    'firstName' => 'John', // optional
    'lastName' => 'Doe', // optional
])->toArray();
```

Run the code in your terminal like so:

```bash theme={null}
php index.php

```

You should see the subscriber on your Novu dashboard.

<Frame>
  <img />
</Frame>

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `updateSubscriber` method like so:

```php theme={null}
// Update subscriber detail
$subscriberId = '7789';
$novu->updateSubscriber($subscriberId, [
    'email' => 'validemail@gmail.com',  // replace with valid email
    'firstName' => '<insert-firstname>', // optional
    'lastName' => '<insert-lastname>', // optional
])->toArray();
```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an array of metadata that you want to attach to the subscriber.

<Note>
  To make all of your app users subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```php theme={null}
$novu->triggerEvent([
    'name' => 'first-email',
    'payload' => ['first-name' => 'Adam'],
    'to' => [
        'subscriberId' => '7789'
    ]
])->toArray();
```

Before running the code, make sure you understand the following:

* The value of `name` should be the workflow’s trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriber ID.

Run the code to trigger a notification!

```php theme={null}
php index.php

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safeguards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```php theme={null}
// Create a Topic
$novu->createTopic([
  'key'  => 'frontend-users',
  'name' => 'All frontend users'
]);
```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers to a topic:

```php theme={null}
$topicKey = 'frontend-users';
$subscribers = [
    '6460925ce1a93324257d2fc1',
    '7789'
];

// Add subscribers to a topic
$novu->topic($topicKey)->addSubscribers($subscribers);
```

On the other hand, if you want to remove subscribers from a topic, do the following:

```php theme={null}
$topicKey = 'frontend-users';
$subscribers = [
    '6460925ce1a93324257d2fc1',
    '7789'
];

// Remove subscribers from a topic
$novu->topic($topicKey)->removeSubscribers($subscribers);
```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```php theme={null}
// Send notifications to a topic (all frontend users)
$novu->triggerEvent([
    'name' => 'first-email',
    'to' => [
       [
         'type' => 'Topic',
         'topicKey' => 'frontend-users'
       ]
    ]
])->toArray();
```

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider and triggered a notification in your application.


# Python quickstart
Source: https://v0.x-docs.novu.co/quickstarts/python

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Python.

In this guide, you'll learn how to use Novu in a Python application. Let's see how you can seamlessly integrate Novu into your Python project!

## Prerequisites

Before diving into the Quickstart, make sure you have the following:

* Python3 installed on your development machine.
* A Novu account. If you don't have one, sign up for free at [web.novu.co](https://web.novu.co?utm_campaign=docs-gs-quick-python)

## Install and Set Up Novu in your Python Project

First, you must install the Novu package in your Python project. From your terminal, you can install the Novu package in your project by running either of the following two commands:

Via pip

```bash theme={null}
pip install novu

```

Via poetry

```bash theme={null}
poetry add novu

```

Once installed, you can import Novu into your project and initialize it using your Novu account credentials. This step establishes a connection between your app and the Novu notification service.

```python theme={null}
from novu.config import NovuConfig

NovuConfig().configure("https://api.novu.co", "<NOVU_API_KEY>")

```

Replace the `<NOVU_API_KEY>` value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-python).

<Note>Please do not hardcode your credentials in a file in production. Use environment variables instead.</Note>

## Set Up A Channel Provider

A channel provider is a service that lets you use one or more notification channels such as sending an email, SMS, push notification etc. Our integration store currently supports four channels: Email, SMS, Chat, and Push. Each of these channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel** at a time. Connect anyone of your preferred providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Notification Workflow

A notification workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber.

The workflow includes the following:

* Notification workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>Proper authorization needs to be set for the Chat channel for subscribers.</Note>

To create a notification workflow, please follow the following steps:

1. Click **Workflows** on the left sidebar of your Novu dashboard.

2. Click the **Add a Workflow** button on the top left.

3. Select **blank workflow** from the dropdown.

4. The name of a new workflow is currently "Untitled." Rename it to a suitable title.

5. Select any channel you want to use in your app. For the sake of this guide, we'll be using the 'Email' channel.
   <Frame>
     <img alt="Set email" />
   </Frame>

6. Click on the recently added channel, fill the email subject and click “Update”.
   <Frame>
     <img alt="Update email template" />
   </Frame>

7. Click on the “Test” tab and send a test email to verify your notification workflow.
   <Frame>
     <img alt="Send test email" />
   </Frame>

You should get an email within seconds. If you didn't, please check your 'spam' folder as sometimes test emails can end up there. Yaaay, you have successfully sent your first notification via the Novu dashboard!

Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display only one subscriber, as you were added automatically during sign-up. If default subscriber is not created, checkout [how to create new subscriber.](/subscribers/subscribers#create-a-subscriber)

<Frame>
  <img alt="Subscriber id" />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```python theme={null}
## Create a subscriber

from novu.api.subscriber import SubscriberApi
from novu.dto.subscriber import SubscriberDto

your_subscriber_id = "123" # Replace this with a unique user ID.

## Define a subscriber instance
subscriber = SubscriberDto(
   subscriber_id=your_subscriber_id,
   email="abc@gmail.com",
   first_name="John",
   last_name="Doe"
)

SubscriberApi().create(subscriber)

```

Run the code in your terminal like so:

```bash theme={null}
python main.py # replace main.py with your file name

```

You should see a new subscriber (that you created above) on your Novu dashboard.

## Update A Subscriber

To update the Subscriber details you can call the put method from SubcriberApi. Here is an example:

```python theme={null}
## Update subscriber detail

from novu.api.subscriber import SubscriberApi
from novu.dto.subscriber import SubscriberDto

subscriber = SubscriberDto(
   subscriber_id="123",
   email="new.abc@gmail.com",
   first_name="New",
   last_name="Name"
)

SubscriberApi().put(subscriber)

```

<Note>To send notifications to all your users, you'll need to make them subscribers in Novu, which you can do by programmatically adding them to Novu.</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```python theme={null}
from novu.api import EventApi

EventApi().trigger(
    name="test",  # The trigger ID of the workflow. It can be found on the workflow page.
    recipients="123",
    payload={},  # Your Novu payload goes here
)

```

Before running the code, make sure you understand the following:

* The value of `name` should be the notification workflow's trigger ID/slug.

<Frame>
  <img alt="Trigger id" />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the notification template content.
* The value of `recipients` is the id of the subscriber on Novu. Replace `123` with your subscriber ID.

Run the code to trigger a notification!

```bash theme={null}
python main.py # replace main.py with your file name

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```python theme={null}
from novu.api import TopicApi

## Create a topic
TopicApi().create(
    key="new-customers", name="New business customers"
)

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```python theme={null}
from novu.api import TopicApi

## Add a list of subscribers to a topic
TopicApi().subscribe(key="new-customers", subscribers="<LIST_OF_SUBSCRIBER_IDs>")

```

On the other hand, if you want to remove subscribers from a topic, do the following:

```python theme={null}
from novu.api import TopicApi

## Unsubscribe a list of subscribers from a topic
TopicApi().unsubscribe(key="new-customers", subscribers="<LIST_OF_SUBSCRIBER_IDs>")

```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```python theme={null}
from novu.api import EventApi
from novu.dto.topic import TriggerTopicDto

topics = TriggerTopicDto(
   topic_key="new-customers",
   type="Topic",
)

EventApi().trigger_topic(
    name="test",  # The trigger ID of the workflow. It can be found on the workflow page.
    topics=topics,
    payload={},  # Your Novu payload goes here
)

```

## Next Steps

Great job! If you've reached this point, you should now have successfully set up a channel provider, created a notification workflow, created a subscriber, updated a subscriber and triggered a notification in your application.

To learn more about notifications and explore Novu's features and capabilities, check out:

* [Novu Digest Engine](/workflows/digest) - Learn how to aggregate multiple trigger events into a single message and deliver it to the subscriber.
* [Novu Python SDK](https://github.com/novuhq/novu-python) - Delve deeper into the SDK and explore a lot of features.
* [Novu Python Cookbook](https://novu-python.readthedocs.io/en/latest/) - Learn how to use the SDK features.


# React
Source: https://v0.x-docs.novu.co/quickstarts/react

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with React.

Send notifications across different channels (SMS, Email, Chat, Push) and enable real-time In-App notifications with the help of a rich and customizable Notification Center.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-react) if you don’t have one yet.
* A working React development environment.

You can find the code for this project [here](https://github.com/novuhq/react-quickstart)

## Install the Novu React Notification Center Package in your React app

The Novu React package provides a React component library that you can use to add a fully functioning notification center to your React application.

To use it, first, install the React Notification Center package by running the following command in your terminal:

```bash theme={null}
npm install @novu/notification-center

```

Before you can use Novu in your React app, you'll need two things:

1. Create a workflow to use for sending notifications, and
2. Create a subscriber - recipient of notifications.

## Create a workflow

Before triggering a notification, we need to create a workflow. A workflow is like a blueprint that all the notifications are supposed to follow.

> The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

These are the steps to create a workflow:

1. Click **Workflow** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **"Untitled"**. Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.

   <Frame>
     <img />
   </Frame>
5. Click on the recently added "In-App" channel and configure it according to your preferences. Once you're done, click "Update" to save your configuration.

   <Frame>
     <img />
   </Frame>

   I'll briefly explain the function of each label in the image above:

* **1-Preview**: This shows you a glimpse of how each notification item will look in the Notification Center UI.
* **2-Avatar**: If turned on, each notification item will show the avatar of the subscriber.
* **3-Action**: With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds**: This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL**: This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter**: This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).
* **7-Editor**: You can add text that you want to be displayed in each notification item. Additionally, you can specify custom variables using `{{ }}`. This means you can inject variables from your code into a notification item's text via a payload.

In our case, we'll use the custom variables functionality, as shown below:

<Frame>
  <img />
</Frame>

Feel free to add only text for now and rename the workflow to quick start. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

<Frame>
  <img />
</Frame>

Now, we’ll learn how to create subscribers on Novu - Recipients of Notifications!

## Create a subscriber

If you click “Subscriber” on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-react), you’ll see the subscriber list. By default, there will only be one subscriber as you’re automatically added as a subscriber when you sign up for Novu:

<Frame>
  <img />
</Frame>

<Note>If you don't see the default subscriber, follow [how to create subscriber](/subscribers/subscribers#create-a-subscriber) documentation to learn on how to create one </Note>

Now, let’s create a subscriber on Novu. After creating a subscriber, we’ll trigger a notification to this subscriber. Subscribers are identified by a unique `subscriberId`.

With Novu, you can create a subscriber using any of its SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin). The NodeJS code to create a subscriber in Novu is:

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<NOVU_API_KEY>");

await novu.subscribers.identify("789", {
  firstName: "Sumit",
  lastName: "Saurabh",
});
```

The `identify` method used above either updates an existing subscriber using the payload data if a subscriber with the same `subscriberId` already exists, or creates a new one if it doesn't. Here, since no subscriber with `firstName` of `Sumit` and `lastName` of `Saurabh` exists, a new one was created and we can now send a notification to this subscriber by triggering a workflow.

<Info>
  You can read more about the `identify` method in our
  [docs](https://docs.novu.co/subscribers/subscribers#create-a-subscriber)
</Info>

You can get your API key from the Novu dashboard. Replace `<NOVU_API_KEY>` with it. Now, head over to the Novu dashboard and see the newly created subscriber above with a `subscriberId` of `789`.

You can also update information about an already existing subscriber using the `subscriber.update` method as shown below:

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<NOVU_API_KEY>");

await novu.subscribers.update("789", {
  firstName: "Saurabh", // new first name
  lastName: "Sumit", // new last name
});
```

## Using Novu in a React app

We have already installed the Novu notification center package above. To use it in an app, simply import it and add the component to your React app as follows:

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
} from "@novu/notification-center";

function App() {
  return (
    <>
      <NovuProvider
        subscriberId={process.env.REACT_APP_SUB_ID}
        applicationIdentifier={process.env.REACT_APP_APP_ID}
      >
        <PopoverNotificationCenter>
          {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
        </PopoverNotificationCenter>
      </NovuProvider>
    </>
  );
}

export default App;
```

You'll notice two things used above - `applicationIdentifier` and `subscriberID`.

An application identifier is a public key used to identify your application. You can get your own application identifier from the [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-react).

And subscribers are users to whom notifications will be sent. They are identified by a `subscriberID` which you can also find in the [Novu subscribers dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-react).

## Trigger a notification

We can trigger a notification by simply running the code below with the correct credentials;

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<API_KEY>");

novu.trigger("quickstart", {
  to: {
    subscriberId: "789",
  },
  payload: {
    description: "Test notification",
  },
});
```

This will take the workflow we created above with the identifier `quickstart` and send a notification to the subscriber with `subscriberId` of `789`.

> Make sure you're executing this code with the correct credentials.

## Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification centre, created a subscriber, a workflow, and triggered a notification in your React application.


# RedwoodJS
Source: https://v0.x-docs.novu.co/quickstarts/redwoodjs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with RedwoodJS.

Send notifications across different channels (SMS, Email, Chat, Push) and enable real-time In-App notifications with the help of a rich and customizable Notification Center in a RedwoodJS app.

Explore the code for [this quickstart on GitHub](https://github.com/novuhq/redwoodjs-quickstart/).

Explore the [live demo](https://novu-redwoodjs-blog.netlify.app/contact).

# Prerequisites

To follow the steps in this quickstart, you'll need:

* A Novu account. If you don't have one, [sign up for free](https://web.novu.co?utm_campaign=docs-gs-quick-redwoodjs).
* Node.js installed on your development machine.

# Create a RedwoodJS app

Clone the popular RedwoodJS blog tutorial app by running the following command in your terminal:

```bash theme={null}
git clone https://github.com/redwoodjs/redwood-tutorial
cd redwood-tutorial
yarn install
yarn rw prisma migrate dev
yarn rw prisma db seed
yarn rw dev

```

# Install Novu

To install Novu's In-App notification center, simply issue the following command:

```bash theme={null}
yarn workspace web add @novu/notification-center

```

Next, install Novu's Node SDK to fire notifications from the api/backend:

```bash theme={null}
yarn workspace api add @novu/node

```

## Register The Notification Center Component

Head over to `web/src/layouts/BlogLayout/BlogLayout.js` file of the recently cloned project and add the Novu In-App Notification center.

The file should look like this:

```javascript theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
} from "@novu/notification-center";

import { Link, routes } from "@redwoodjs/router";

import { useAuth } from "src/auth";

const BlogLayout = ({ children }) => {
  const { logOut, isAuthenticated, currentUser } = useAuth();
  const SUBSCRIBER_ID = process.env.REDWOOD_ENV_SUBSCRIBER_ID;
  const APPLICATION_IDENTIFIER = process.env.REDWOOD_ENV_APPLICATION_IDENTIFIER;

  return (
    <>
      <header className="relative flex justify-between items-center py-4 px-8 bg-blue-700 text-white">
        <h1 className="text-5xl font-semibold tracking-tight">
          <Link
            className="text-blue-400 hover:text-blue-100 transition duration-100"
            to={routes.home()}
          >
            Redwood Blog with <em>Novu</em>
          </Link>
        </h1>
        <nav>
          <ul className="relative flex items-center font-light">
            <li>
              <NovuProvider
                subscriberId={SUBSCRIBER_ID}
                applicationIdentifier={APPLICATION_IDENTIFIER}
              >
                <PopoverNotificationCenter
                  showUserPreferences={true}
                  position="top-start"
                >
                  {({ unseenCount }) => (
                    <NotificationBell unseenCount={unseenCount} />
                  )}
                </PopoverNotificationCenter>
              </NovuProvider>
            </li>
            <li>
              <Link
                className="py-2 px-4 hover:bg-blue-600 transition duration-100 rounded"
                to={routes.about()}
              >
                About
              </Link>
            </li>
            <li>
              <Link
                className="py-2 px-4 hover:bg-blue-600 transition duration-100 rounded"
                to={routes.contact()}
              >
                Contact
              </Link>
            </li>
            <li>
              {isAuthenticated ? (
                <div>
                  <button type="button" onClick={logOut} className="py-2 px-4">
                    Logout
                  </button>
                </div>
              ) : (
                <Link to={routes.login()} className="py-2 px-4">
                  Login
                </Link>
              )}
            </li>
          </ul>
          {isAuthenticated && (
            <div className="absolute bottom-1 right-0 mr-12 text-xs text-blue-300">
              {currentUser.email}
            </div>
          )}
        </nav>
      </header>
      <main className="max-w-4xl mx-auto p-12 bg-white shadow rounded-b">
        {children}
      </main>
    </>
  );
};

export default BlogLayout;
```

<Note>
  Add `REDWOOD_ENV_APPLICATION_IDENTIFIER` and `REDWOOD_ENV_SUBSCRIBER_ID` to
  the `.env` file.
</Note>

The `Subscriber ID` ideally should be the `id` of the **logged in user**. When a user logs into your app, they’ll be able to see all their notifications in the notification center. For this to work successfully, the user should have been created as a subscriber on Novu.

The `Application Identifier` is a public key used to identify your application.

Head over to your [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-redwoodjs), copy the application identifier and add it as the value of `REDWOOD_ENV_APPLICATION_IDENTIFIER`.

Head over to [the Subscribers page](https://web.novu.co/subscribers?utm_campaign=docs-quick-redwoodjs), grab a subscriber identifier and add it as the value of `REDWOOD_ENV_SUBSCRIBER_ID` in the `.env` file.

Now, check your app, you will see a notification bell button. Click on the button to reveal the notification center UI. Voila!

<Note>
  There are no notifications because none has been triggered yet. When
  notifications are sent to a subscriber, it will show up in the UI. Next, we'll
  learn how to trigger notifications.
</Note>

# Create A Workflow

The first step to trigger notifications is to create a workflow. A workflow is like a map that holds the entire flow of messages sent to the subscriber.

<Note>The recipients of a triggered notification are called subscribers.</Note>

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Add a workflow** button on the top left.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.
5. Click on the recently added In-App channel and configure it.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).

In the In-App channel `Editor`, add the following content and rename the step to `Onboarding In App` :

```javascript theme={null}
Hi {{ name }},
<br/>
<p>Thanks for indicating interest in attending RedwoodJS conference. Here is your message: </p>

<p>{{ message }}</p>

```

<Note>
  `{{ name }}` and `{{ message }}` are payload values that will be passed on from
  our code to the workflow template so it can appear in the notification sent to
  subscribers.
</Note>

Click on the `Update` button to save the configuration successfully!

6. In the workflow page, drag and drop the **Email** channel to the workflow canvas to be just below the `In-App` channel.
7. Click on the recently added Email channel and configure it:

Add `Sender name` and `Subject`. Ensure the `Default Layout` is selected for the Email Layout.

Switch to the `Custom Code` section and add the following:

```javascript theme={null}
Hi {{ name }},

<br />
<p>Thank you for attending RedwoodJS Conference. This means a lot to us!</p>
<br />
<p>Here is your message:</p>

{{ message }}

```

Finally, give the workflow a name. We'll need the workflow trigger identifier ***(which is the slug of the name)*** later.

Next, we’ll learn how to trigger notifications to subscribers.

# Trigger A Notification

Open up `api/src/services/contacts/contacts.js`, and add the following code into your app to trigger a notification:

```javascript theme={null}
import { Novu } from '@novu/node'

const novu = new Novu(process.env.NOVU_API_KEY)

export async function sendNotification(email, name, message) {
  await novu.trigger('<workflow-trigger-id>', {
    to: {
      subscriberId: process.env.REDWOOD_ENV_SUBSCRIBER_ID,
      email: email,
    },
    payload: {
      name: name,
      message: message,
    },
  })
}

...

...

/** In the createContact code, call the sendNotification and pass in the email, name and message */
export const createContact = ({ input }) => {
  validate(input.email, 'email', { email: true })

  sendNotification(input.email, input.name, input.message)

  return db.contact.create({
    data: input,
  })
}

...
...

```

Before running the code, make sure you understand the following:

* The value of `<workflow-trigger-id>` should be the workflow’s trigger ID/slug.
* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu.
* Ensure `NOVU_API_KEY` is in the `.env` file and with the appropriate value gotten from the dashboard.

# One more thing

Head over to the [integrations store on your Novu dashboard](https://web.novu.co/integrations?utm_campaign=docs-quick-redwoodjs).

Select the **Novu Email Test Provider**, and mark as the primary provider for Emails. This ensures that all emails are sent via the Novu Email provider.

# Test the app

Ensure your app is still running and head over the `/contact` page in the app. Fill the form and click `Save`.

The app will trigger two notifications:

* An In-App notification
* An Email notification

# Conclusion

Great job! If you've reached this point, you should now have successfully created workflow, configured a channel provider, triggered a workflow, and sent an email and In-App notification.


# Ruby quickstart
Source: https://v0.x-docs.novu.co/quickstarts/ruby

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Ruby.

Learn how to integrate Novu into your Ruby project on the fly and send notifications across different channels (SMS, Email, Chat, Push).

Let's get started! 💪

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-ruby) if you don’t have one yet.
* A working Ruby development environment with at least version 2.6.0.

You can also [view the completed code](https://github.com/novuhq/novu-ruby-quickstart) of this quick start in a GitHub repo.

## Install Novu Ruby SDK

The [Ruby SDK](http://github.com/novuhq/novu-ruby) provides a fluent and expressive interface for interacting with Novu's API and managing notifications.

You can install the client library via RubyGems:

```ruby theme={null}
gem install novu

```

Or add it to your Gemfile:

```ruby theme={null}
gem 'novu'

```

Then run `bundle install`.

## Initialize & Configure the Novu Ruby SDK

To use the library, Create a new file `index.rb` then initialize the client with your API token:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

```

Replace the `<NOVU_API_KEY>` argument with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-ruby).

<Note>
  Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

To test your API key, call the methods on the client to interact with the Novu API and display the result on your ruby console:

```ruby theme={null}
puts client.notifications

```

Run the file `index.rb`:

```bash theme={null}
ruby index.rb

```

You should see a result as below:

```json theme={null}
{
  "page": 0,
  "totalCount": 0,
  "pageSize": 10,
  "data": []
}

```

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-ruby) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favorite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create A Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.

<Frame>
  <img />
</Frame>

3. The name of the new workflow is currently Untitled, rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select Email as the channel you want to add, by dragging it from the right sidebar.

<Frame>
  <img />
</Frame>

5. Click on the Email in the workflow and edit it as per this image. Don’t forget to add the fields in the editor which is supposed to be updated with dynamic values that will be sent when calling the API.

<Frame>
  <img />
</Frame>

6. Also, add the variables in the Variables section in the test tab and try testing it by sending the email to your email address using the Send Test Email button at the bottom right.

<Frame>
  <img />
</Frame>

You should get an email within seconds! 👌

Great, you have successfully sent your first notification via the Novu dashboard! Now, let’s take a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## Create subscriber

create_payload = {
    'subscriberId' => '7789', # replace with system_internal_user_id
    'firstName' => 'John', # optional
    'lastName' => 'Doe', # optional
}
client.create_subscriber(create_payload)

```

Run the code in your terminal:

```bash theme={null}
ruby index.rb

```

You should see the subscriber on your Novu dashboard.

\![https://res.cloudinary.com/dxc6bnman/image/upload/f\_auto,q\_auto/v1685466979/guides/Screenshot\_2023-05-14\_at\_11.06.38\_ugvmc0.png](https://res.cloudinary.com/dxc6bnman/image/upload/f_auto,q_auto/v1685466979/guides/Screenshot_2023-05-14_at_11.06.38_ugvmc0.png)

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `updateSubscriber` method like so:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## Update subscriber detail

update_payload = {
    'email' => 'validemail@gmail.com',  # replace with valid email
    'firstName' => '<insert-firstname>', # optional
    'lastName' => 'Obasanjo', # optional
}
client.update_subscriber('7789', update_payload);
```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an object of metadata that you want to attach to the subscriber.

<Note>
  To make all of your app users subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## trigger a notification

trigger_payload = {
    'name' => 'Trigger1',
    'payload' => {
        'first-name' => 'Adam'
    },
    'to' => {
        'subscriberId' => '7789'
    }
}
client.trigger_event(trigger_payload)

```

Before running the code, make sure you understand the following:

* The value of `name` should be the workflow’s trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriber ID.

Run the code to trigger a notification!

```bash theme={null}
ruby index.rb

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safeguards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')
## Create a Topic

create_topic_payload = {
    'key'  => 'frontend-users',
    'name' => 'All frontend users'
}
client.create_topic(create_topic_payload)

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add and Remove Subscribers to a Topic

Copy and paste the following code into your app to add subscribers to a topic:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

topicKey = 'frontend-users'
subscribers = ['6460925ce1a93324257d2fc1', '7789'].to_s

## Add subscribers to a topic
client.add_subscribers(topicKey, subscribers)

```

Also, you can remove subscribers from a topic by using the code snippet below:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

topicKey = 'frontend-users'
subscribers = ['6460925ce1a93324257d2fc1', '7789'].to_s

## Remove subscribers from a topic
client.remove_subscribers(topicKey, subscribers)

```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## Send notifications to a topic (all frontend users)
client.trigger_event({
    'name' => 'Trigger1',
    'to' => {
        'type' => 'Topic',
        'topicKey' => 'frontend-users'
    }
})

```

<Note>
  The value of the `name` key in the payload should be the name of the notification created earlier.
</Note>

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider and triggered a notification in your application.


# VanillaJS
Source: https://v0.x-docs.novu.co/quickstarts/vanillajs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with VanillaJS.

Learn how to integrate Novu into your vanilla JS app on the fly. Send notifications across different channels (SMS, Email, Chat, Push) and enable real-time In-App notifications with the help of a rich and customizable Notification Center.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-vanilla) if you don’t have one yet.
* A working Vanilla JS development environment.

You can find the code for this project [here](https://github.com/novuhq/vanillajs-quickstart)

## Loading Notification center component from the CDN

The Notification Center Web Component is a custom element that can be used in any web application.

You can find out more about the web component [here](https://docs.novu.co/notification-center/web-component/).

In our case, we'll be using the bundled version of the Notification Center Web Component that is available on the CDN.

You can load the Notification center component using the CDN as follows:

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    ...
    <!-- CDN link for Novu notification center component -->
    <script src="​https://web-component.novu.co/index.js"></script>
  </head>
  <body>
    <!-- HTML body -->
    <!-- the notification center -->
    <notification-center-component
      style="display: inline-flex"
      application-identifier="<YOUR_APPLICATION_IDENTIFIER>"
      subscriber-id="<YOUR_SUBSCRIBER_ID>"
    ></notification-center-component>
  </body>
</html>

```

You'll notice the use of two things in the above code - `application-identifier` and `subscriber-id`.

An application identifier is a public key used to identify your application. You can get your own application identifier from the [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-vanilla).

And subscribers are users to which notifications will be sent. They are identified by a `subscriberID` which you can also find in the [Novu subscribers dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-vanilla). Let's learn more about subscribers.

## Subscribers in Novu

If you click “Subscriber” on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-vanilla), you’ll see the subscriber list. By default, there will only be one subscriber as you’re automatically added as a subscriber when you sign up for Novu:

<Frame>
  <img />
</Frame>

<Note>If you don't see the default subscriber, follow [how to create subscriber](/subscribers/subscribers#create-a-subscriber) documentation to learn on how to create one </Note>

Now, let’s create a subscriber on Novu. After creating a subscriber, we’ll trigger a notification to this subscriber. Subscribers are identified by a unique `subscriberId`.

With Novu, you can create a subscriber using any of its SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin). The code to create a subscriber in Novu is:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.identify('123', {
  firstName: 'Sumit',
  lastName: 'Saurabh',
  returnUser: true,
});
```

You can get your API key from the Novu dashboard. Replace `<NOVU_API_KEY>` with it. Now, if you’ll go to the Novu dashboard, you shall see the subscriber we created above with `subscriberId` of `123`.

You can also update information about an already existing subscriber using the `subscriber.update` method as shown below:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('123', {
  firstName: 'Saurabh', // new first name
  lastName: 'Sumit', // new last name
});
```

## Create a workflow

Before triggering a notification, we need to create a workflow. A workflow is like a blueprint that all the notifications are supposed to follow.

> The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

These are the steps to create a workflow:

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **"Create Workflow"** button on the top right.
3. The name of the new workflow is currently **"Untitled"**. Rename it to a more suitable title.
4. Select **"In-App"** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added In-App channel and configure it according to your preferences. Once you’re done, click Update to save your configuration.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.

In our case, we'll use the custom variables functionality, as shown below:

<Frame>
  <img />
</Frame>

Feel free to add only text for now and rename the workflow to quickstart. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

Having created a workflow and having our `subscriberID`, we're ready to send notifications using Novu!

## Using Novu in a vanilla JS app

We have already used the CDN to get the notification center component and we already have all the credentials that we need. To use it in an app, simply use the `notification-center-component` in your html file as shown below.

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    ...
    <!-- CDN link for Novu notification center component -->
    <script src="​https://web-component.novu.co/index.js"></script>
  </head>
  <body>
    <notification-center-component
      style="display: inline-flex"
      application-identifier="<YOUR_APPLICATION_IDENTIFIER>"
      subscriber-id="<YOUR_SUBSCRIBER_ID>"
    ></notification-center-component>

    <script>
      // here you can attach any callbacks, interact with the web component API
      // You can also move this to a separate js file and have all the callbacks and other logic there
      let nc =document.getElementsByTagName('notification-center-component')[0];
      nc.onLoad = () => console.log('hello world!');
    </script>
  </body>
</html>
```

You can add all the logic you want to add to the `script` element at the bottom or move it all into a separate JavaScript file (don't forger to link to the JavaScript file in this case).

Here's an example of such an HTML file:

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <script src="​https://web-component.novu.co/index.js"></script>

    <title>Vanilla JS app</title>
  </head>

  <body>
    <div>
      <h1>Notification generator</h1>
      <notification-center-component
        style="display: inline-flex"
        application-identifier="<YOUR_NOVU_APPLICATION_IDENTIFIER>"
        subscriber-id="123"
      ></notification-center-component>
    </div>
    <div class="">
      <form action="#" method="post" class="form">
        <input class="input" placeholder="Enter notification text" type="text" name="description" />
        <button class="btn">Send</button>
      </form>
    </div>
  </body>
  <script src="./app.js"></script>
</html>
```

And the corresponding script file is as follows:

```jsx theme={null}
const btn =document.querySelector('.btn');
const input =document.querySelector('.input');
const form =document.querySelector('.form');

const onClickHandler = async (e) => {
  e.preventDefault();
  const desc = input.value;
  console.log(desc);
  try {
    const resp = await fetch('<The API route from your backend>', {
      method: 'POST',
      body: JSON.stringify({
        description: desc,
      }),
      headers: {
        'Content-Type': 'application/json',
      },
    });
    input.value = '';
    console.log(resp);
  } catch (err) {
    console.log(err);
  }
};

form.addEventListener('submit', onClickHandler);

// here you can attach any callbacks, interact with the web component API
let nc =document.getElementsByTagName('notification-center-component')[0];
nc.onLoad = () => console.log('hello world!');
```

The front-end as well as the back-end code for the sample application can be found [here](https://github.com/novuhq/vanillajs-quickstart) for illustration.

## Code to trigger the notification

We can trigger a notification by simply executing the trigger code snippet we get from the Novu web dashboard.

To get the snippet:

1. Go to **Workflows** in the left sidebar on Novu web dashboard.
2. Select the workflow.
3. Click the **Get Snippet** button on the top right.

Here's the trigger snippet you'll receive:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<API_KEY>');

novu.trigger('quickstart', {
  to: {
    subscriberId: '<REPLACE_WITH_DATA>',
  },
  payload: {
    description: '<REPLACE_WITH_DATA>',
  },
});
```

> Make sure you're executing this code with the correct credentials.

## Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, configured a channel provider and triggered a notification in your React application.


# Vue
Source: https://v0.x-docs.novu.co/quickstarts/vue

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Vue.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications and integrate a rich, customizable and ready-to-use realtime UI In-App notification center in Vue apps.

# Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-vue) if you don’t have one yet.
* A working Vue development environment with a Vue 3 version.

You can also [view the completed code](https://github.com/novuhq/vue-quickstart) of this quick start in a GitHub repo.

# Create a new Vue app

If you already have a working Vue app, please feel free to skip this section.

Create a new Vue 3 app by running the following command in your terminal:

```bash theme={null}
npx create-vue notifications-app
```

Interactively run through the questions and answer them according to your preference. Then `cd` into the `notifications-app` folder and run the following:

```bash theme={null}
npm install && npm run format && npm run dev
```

# Install Novu Vue Notification Center Package

The Novu Vue package provides a Vue component wrapper over the web component that you can use to integrate the notification center into your Vue application.

Now install the Vue Notification Center package by running the following command in your terminal:

```bash theme={null}
npm install @novu/notification-center-vue
```

## Register The Notification Center Plugin

First, register the notification center plugin in your app as a global component.

In your `main.js` or `main.ts` file, add it like so:

```tsx theme={null}
import { createApp } from 'vue';

import NotificationCenterPlugin from '@novu/notification-center-vue';
import '@novu/notification-center-vue/dist/style.css';

// your app component
import App from './App.vue';

const app = createApp(App);

app.use(NotificationCenterPlugin);
app.mount('#app');
```

# Use The Notification Center Component

Create a new file, `NotificationCenter.vue` in the `src/components` directory. This file will house the Notification Center component.

Add the `NotificationCenterComponent` like so:

***Using the Composition API***

```tsx theme={null}
<script lang="ts" setup>
    const subscriberId = 'INSERT_SUBSCRIBER_ID_HERE'
    const applicationIdentifier = import.meta.env.NOVU_APP_IDENTIFIER
    const sessionLoaded = () => {
        console.log("Notification Center session loaded successfully!")
    }
</script>

<template>
    <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>
```

src/components/NotificationCenter.vue

***Using the Options API***

```tsx theme={null}
<script lang="ts">
export default {
  data() {
    return {
      applicationIdentifier: import.meta.env.VITE_NOVU_APP_IDENTIFIER,
      subscriberId: 'INSERT_SUBSCRIBER_ID_HERE',
    };
  },
  methods: {
    sessionLoaded() {
      console.log('Session loaded!')
    },
  },
};
</script>

<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>
```

src/components/NotificationCenter.vue

The `subscriberId` ideally should be the `id` of the **logged in user**. When a user logs into your app, they’ll be able to see all their notifications in the notification center. For this to work successfully, the user should have been created as a subscriber on Novu.

The `applicationIdentifier` is a public key used to identify your application. Obtain it from your [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-vue), and add it to your `.env` file.

If there’s none, create a `.env` file and add it like so:

```
VITE_NOVU_APP_IDENTIFIER = YOUR_NOVU_APP_IDENTIFIER;
```

Replace `YOUR_NOVU_APP_IDENTIFIER` with the real value from your dashboard.

# Display The In-App Notification Center UI

If you started by creating a new Vue app, then do the following:

Head over to `src/views/HomeView.vue` and import the `NotificationCenter.vue` component.

Replace the entire file with the code below:

```tsx theme={null}
<script setup lang="ts">
import NotificationCenter from '../components/NotificationCenter.vue'
</script>

<template>
  <main>
    <NotificationCenter />
  </main>
</template>
```

src/views/HomeView\.vue

Run your app again. You will see a button with the text **Notifications: 0**. Click on the button to reveal the notification center UI. Voila!

<Note>
  There are no notifications because none has been triggered yet. When notifications are sent to a subscriber, it will show up in the UI. Next, we'll learn how to trigger notifications.
</Note>

There’s a probability you might want the general notification bell icon. By default, the component displays the bell icon.

Simply delete the button element. Your component should look like this:

```jsx theme={null}
<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
  </NotificationCenterComponent>
</template>
```

You should now see a **bell button** that opens the notification center when clicked. This bell can be customized to your preference, and we will style and modify it in a later step.

* [Vue Notification Center Example Repo](https://github.com/novuhq/examples/tree/main/vue-notification-center-example)

# Create A Workflow

The first step to trigger notifications is to create a workflow. A workflow is like a map that holds the entire flow of messages sent to the subscriber.

<Note>
  The recipients of a triggered notification are called subscribers.
</Note>

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added In-App channel and configure it according to your preferences. Once you’re done, click Update to save your configuration.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).

Feel free to add only text for now and rename the workflow to `Onboarding In App`. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Next, we’ll learn how to create subscribers on Novu - *Recipients of Notifications*

# Create A Subscriber

Click **Subscribers** on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-vue) to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu.

Novu has a plethora of backend SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin) to choose from to create a subscriber programmatically. This is the recommended method.

Obtain your API key from your [Novu dashboard.](https://web.novu.co/settings?utm_campaign=docs-quick-vue) Replace `<NOVU_API_KEY>` with it.

Now check your Novu dashboard. You should see the recently created subscriber.

You can also update the subscriber info like so:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('132', {
  email: 'janedoe@domain.com', // new email
  phone: '+19874567832', // new phone
});
```

# Trigger A Notification

To trigger a notification, simply run the codesandbox below with the correct credentials.

```jsx theme={null}
// code to trigger a notification
```

`onboarding-in-app` is the workflow identifier we created earlier.

Ensure the `subscriberId` value in the backend code that triggers the notification matches the `subscriberId` in your **NotificationCenterComponent** code.

```tsx theme={null}
<template>
    <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>

<script lang="ts" setup>
    const subscriberId = '132'
    const applicationIdentifier = import.meta.env.NOVU_APP_IDENTIFIER
    const sessionLoaded = () => {
        console.log("Notification Center session loaded successfully!")
    }
</script>
```

Check your app again. You should see the recently triggered notification!

# Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, configured a channel provider and triggered a notification in your Vue application.


# Preferences
Source: https://v0.x-docs.novu.co/subscribers/preferences



Novu provides a way to store user preferences in the subscribers data model.
This allows subscribers to specify and manage their preferences, without your intervention. Customizing preferences has become the standard expected behavior for people and Novu can take the technical burden of managing preferences off of you.

**Novu allows several levels of preferences:**

* Workflow level channel preferences
* Subscriber level channel preferences
* Global level channel preferences

## Workflow level channel preferences

When creating a new workflow on the Web platform, you can specify default preferences for the subscribers in channel settings. They will be used unless the subscriber overrides them by his own custom preference.

This will allow you to create sensible defaults but still provide the user with the ability to override them. Template level preference can be managed in channel settings. All channels are `ON` unless specified otherwise.

`Workflow Settings > Channels`

<img />

## Subscriber level channel preferences

Our notification center component will show a user the available preferences, user will be able to modify on the channel level. Critical workflows will be excluded from the list. Click on cog (setting) icon on notification center component to open subscriber channel preferences page.

<img />

<Note>
  Only channels with a matched step will be returned from the API in
  notification center preference page. In case no channel content was found, the
  API will return an empty array.
</Note>

## Global level channel preferences

<Info>Since v0.20.0</Info>

Subscribers can set global channel preferences, which override individual settings. For instance, if there are 10 workflows, and a subscriber wants to disable SMS notifications for all of them, they can do so with a single global preference.

### Get subscriber global preference

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.getGlobalPreference("subscriberId" );
    ```
  </Tab>
</Tabs>

[Get subscriber's global preference API](/api-reference/subscribers/get-subscriber-global-preferences)

### Update subscriber global preference

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    // enable in-app channel and disable email channel
    await novu.subscribers.updateGlobalPreference("subscriberId", {
      enabled: true,
      preferences: [{
        type: "in_app"
        enabled: true
      }, {
        type: "email"
        enabled: false
      }]
    });
    ```
  </Tab>
</Tabs>

[Update subscriber's global preference API](/api-reference/subscribers/update-subscriber-global-preference)

<Note>Global subscriber preference can be updated and accessed using API and SDK only. Currently we have not added support of global subscriber preference in UI.</Note>

## Exclude workflows from preferences (critical workflow)

In some cases, you don't want the subscriber to be able to unsubscribe from mandatory notifications such as Account Verification, Password Reset, etc...

In those cases you can turn off the toggle `Users will be able to manage subscriptions` in channel settings. Workflow will become `critical`, once this toggle is turned `OFF`. By default, every workflow is `non-critical` and subscribers can manage channel preferences irrespective of workflow-level channel preferences. Critical workflow will not show on the subscriber preferences page.

## Get subscriber preferences

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from "@novu/node";

    const novu = new Novu("<NOVU_API_KEY>");

    // 111 is subscriberId
    await novu.subscribers.getPreference("111");
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    // 111 is subscriberId
    $novu->getSubscriberPreferences('111')->toArray();
    ```
  </Tab>
</Tabs>

## Get subscriber preference by level

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu, PreferenceLevelEnum } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');
    // Get global level preference
    await novu.subscribers.getPreferenceByLevel("subscriberId", PreferenceLevelEnum.GLOBAL)

    // Get template level preference
    await novu.subscribers.getPreferenceByLevel("subscriberId", PreferenceLevelEnum.TEMPLATE);
    ```
  </Tab>
</Tabs>

## Update subscriber preference for a workflow

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu, ChannelTypeEnum } from "@novu/node";

    const novu = new Novu("<NOVU_API_KEY>");

    // enable in_app channel
    await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
      enabled: true,
      channel: { type: ChannelTypeEnum.IN_APP, enabled: true },
    });

    // enable email channel
    await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
      enabled: true,
      channel: { type: ChannelTypeEnum.EMAIL, enabled: true },
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    // enable in_app channel
    $novu->updateSubscriberPreference('subscriberId', 'workflowIdentfier', [
        'enabled' => true
        'channel' => [
          'type' => 'in_app',
          'enabled' => true
        ]
    ]);

    // enable email channel
    $novu->updateSubscriberPreference('subscriberId', 'workflowIdentfier', [
        'enabled' => true
        'channel' => [
          'type' => 'email',
          'enabled' => true
        ]
    ]);
    ```
  </Tab>
</Tabs>

## Order of priority of preferences

1. if `Users will be able to manage subscriptions` toggle is turned off i.e workflow is critical, this will override workflow level and subscriber level preferences and notification will always be sent.
2. if workflow is non critical and subscriber has `false` value set for `enabled` field in preference then all other channels will become inactive even if they have `true` state.
3. if workflow is non critical and subscriber has `true` value set for `enabled` field in preference then notification will be filtered based on subscriber channel preference.
4. Workflow level channel preferences will be applied to all subscribers by default unless subscriber overrides them.

`Example`

1. For `First Workflow`, `critical` is false, `enabled` is true, in\_app, email, push channels are true and sms, chat channels are false. As per above order of priority of preferences, notification will be filtered as per the subscriber preferences. The subscriber will receive in-app, email and push notifications, but not receive sms and chat notifications.

2. For `Second Workflow`, `critical` is false, `enabled` is false, all channels are true. As per above order of priority of preferences, subscriber will not receive any type of notification because all channels become disabled due to false value of `enabled` field.

3. For `Third Workflow`. `critical` is true, `enabled` is false, email, chat channels are false and the other three channels are true. As per above order of priority of preferences, subscriber will receive all type of notifications as this workflow is `critical`.

<Tabs>
  <Tab title="First Workflow">
    ```json theme={null}
    {
      "template": {
        "_id": "firstWorkflowIdentifier",
        "name": "First Workflow",
        "critical": false
      },
      "preference": {
        "enabled": true,
        "channels": {
          "in_app": true,
          "email": true,
          "sms": false,
          "push": true,
          "chat": false
        }
      }
    }
    ```
  </Tab>

  <Tab title="Second Workflow">
    ```json theme={null}
    {
      "template": {
        "_id": "secondWorkflowIdentifier",
        "name": "Second Workflow",
        "critical": false
      },
      "preference": {
        "enabled": false,
        "channels": {
          "in_app": true,
          "email": true,
          "sms": true,
          "push": true,
          "chat": true
        }
      }
    }
    ```
  </Tab>

  <Tab title="Third Workflow">
    ```json theme={null}
    {
      "template": {
        "_id": "thirdWorkflowIdentifier",
        "name": "Third Workflow",
        "critical": true
      },
      "preference": {
        "enabled": false,
        "channels": {
          "in_app": true,
          "email": false,
          "sms": true,
          "push": true,
          "chat": false
        }
      }
    }
    ```
  </Tab>
</Tabs>

## API

<CardGroup>
  <Card title="Get subscriber preferences API" icon="plug" href="/api-reference/subscribers/get-subscriber-preferences" />

  <Card title="Update subscriber preference for a workflow API" icon="plug" href="/api-reference/subscribers/update-subscriber-preference" />

  <Card title="Update workflow API" icon="plug" href="/api-reference/workflows/update-workflow" />
</CardGroup>

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="How to change enabled field from UI?">
    This field can only be changed using API.
  </Accordion>

  <Accordion title="What preferences are applied to a subscriber when we create a new workflow?">
    In the case of a new workflow, the subscriber will inherit all preferences
    from the workflow\.However, after subsequent preference updates, the
    subscriber's preferences will not inherit workflow-level preferences.
  </Accordion>

  <Accordion title="How to disable a workflow for a single subscriber?">
    You can turn off all workflow's channels for a subscriber using [subscriber preference](/subscribers/preferences#subscriber-level-channel-preferences). If all channels are off, then the subscriber will not receive any message from any channel step and hence workflow is disabled for that subscriber
  </Accordion>
</AccordionGroup>


# Subscribers
Source: https://v0.x-docs.novu.co/subscribers/subscribers



In Novu, we call the entities designed to receive notifications as `Subscribers`. Each subscriber is unique and identified by a unique subscriberId.

<Note>
  `subscriberId` is a unique identifier used by Novu to keep track of a specific subscriber.
  We recommend using the internal unique id your application uses for a specific user.
</Note>

Each subscriber has the following data points:

* **User Data** - Data stored in the subscriber object that you can easily access in your notification templates. This contains basic info such as first name, last name, avatar, locale, email, and phone. This data is fixed and structured.
* **Custom Data** - Apart from the above fixed structured user data, any unstructured custom data such as user's address, nationality, height, etc can also be stored in the `data` field using key-value pairs.
* **Channel Specific Credentials** - `deviceTokens` required to send push notifications and `webhookUrl` for chat channel providers can also be stored.

## Subscriber attributes

| Field        | Type   | Required | Example                                                                        |
| :----------- | :----- | :------- | :----------------------------------------------------------------------------- |
| subscriberId | string | true     | b0bea066-f5fe-11ed-b67e-0242ac120002                                           |
| firstName    | string | false    | John                                                                           |
| lastName     | string | false    | Doe                                                                            |
| email        | string | false    | [john.doe@domain.org](mailto:john.doe@domain.org).                             |
| phone        | string | false    | +13603963366                                                                   |
| locale       | string | false    | en                                                                             |
| avatar       | string | false    | [https://example.com/images/avatar.jpg](https://example.com/images/avatar.jpg) |
| data         | object | false    | `{"key": "value"}`                                                             |

## Subscriber response schema

**Novu subscriber object**

```json theme={null}
{
  "_id": "NOVU_GENERATED_SUBSCRIBER_ID",
  "_organizationId": "NOVU_GENERATED_ORG_ID",
  "_environmentId": "NOVU_GENERATED_ENV_ID",
  "firstName": "John",
  "lastName": "Doe",
  "subscriberId": "subscriberId",
  "email": "[john.doe@org.com](mailto:john.doe@org.com)",
  "phone": "+98712345670"
  "data": {
    "custome_key_1" : "custom_value_1",
    "custome_key_2" : "custom_value_2"
  }
  "channels": [
  {
    "credentials": {
      "deviceTokens": [
        "token1",
        "token2"
      ]
    },
    "_integrationId": "NOVU_GENERATED_INTEGRATION_ID",
    "providerId": "fcm"
  },
  {
    "credentials": {
      "webhookUrl": "URL"
    },
    "_integrationId": "NOVU_GENERATED_INTEGRATION_ID",
    "providerId": "discord"
  }
  ],
  "deleted": false,
  "createdAt": "2022-10-13T17:40:53.231Z",
  "updatedAt": "2022-10-13T17:41:53.238Z",
  "__v": 0,
  "isOnline": false,
  "lastOnlineAt": "2022-10-13T17:41:53.238Z",
  "avatar": "AVATAR_URL",
  "id": "NOVU_GENERATED_SUBSCRIBER_ID"
}
```

## Create a subscriber

You can create a subscriber in Novu using the `identify` method provided in Novu's SDK.

<Tip>The `identify` method serves the purpose of handling existing "subscriberId" providers within the database.
When a provider with the same subscriberId already exists, this method performs an update operation using the data present in the payload.
In cases where there is no pre-existing entry, the method generates a new one, thus exhibiting an <Tooltip>upsert</Tooltip>
behavior.</Tip>

<Note>
  It is possible for two subscribers to have the same email address in our system. This is because the `subscriberId` is the unique identifier that distinguishes one subscriber from another.
</Note>

```jsx theme={null}
import { Novu } from "@novu/node";

// Insert your Novu API Key here
const novu = new Novu("<NOVU_API_KEY>");

// Create a subscriber on Novu
await novu.subscribers.identify("132", {
  email: "john.doe@domain.com",
  firstName: "John",
  lastName: "Doe",
  phone: "+13603963366",
});
```

<Warning> The `phone` parameter must be parsed as a string.</Warning>

You should now be able to see your new subscriber on the Novu dashboard.

You can also add additional fields such as `phone`, `avatar`, and `data`.

<Note> Remember, all user IDs added to Novu need to be unique. </Note>

If you face issues with the subscriber creation only taking the user ID and omitting other fields such as firstName, lastName, etc., you could consider updating the subscriber after creation.

Please also be aware that although it's currently possible to create a subscriber with an empty `subscriberId`, this subscriber cannot be deleted later.

We support creating new subscriber using two ways, `Ahead of Trigger` means adding subscribers before triggering notification or `Inline of Trigger` means sending complete subscriber data in `to` field while triggering.

### 1. Ahead of Trigger

Create the subscriber and then trigger the notification to this subscriber. Here `subscriberId` is the required field and other fields are optional.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.identify('111', {
      email: 'john.doe@domain.com',
      firstName: 'John',
      lastName: 'Doe',
      phone: '+13603963366',
      avatar: 'https://example.com/images/avatar.jpg',
      locale: 'en-US',
      data: { customKey1: 'customVal1', customKey2: 'customVal2' },
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->createSubscriber([
        'subscriberId' => '111',
        'email' => 'john.doe@domain.com',
        'firstName' => 'John',
        'lastName' => 'Doe',
        'phone' => '+13603963366',
        'avatar' => 'https://example.com/images/avatar.jpg',
        'locale' => 'en',
        'data' => [
          'customKey1' => 'customVal1',
          'customKey2' => 'customVal2'
        ]
    ]);
    ```
  </Tab>
</Tabs>

Novu will create a subscriber if one does not exist and will update the existing subscriber based on the `identify` payload. You can call this function during registration or signup to make sure the subscriber data is up-to-date, if you wish to save additional attributes with a subscriber, you can pass additional custom data in the **data** field as key-value pairs.

### 2. Inline of Trigger

A non-existing subscriber can be added by sending subscriber data in `to` field of the trigger method. If any subscriber with provided `subscriberId` does not exists, a new subscriber will be created. In this case, subscriber will be created first and then the trigger will be executed synchronously.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '111',
        email: 'john.doe@domain.com',
        firstName: 'John',
        lastName: 'Doe',
        phone: '+13603963366',
      },
      payload: {
        customVariable: 'variableValue',
        organization: {
          logo: 'https://organization.com/logo.png',
        },
      },
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->triggerEvent([
      'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
      'to' => [
          'subscriberId' => '111',
          'email' => 'john.doe@domain.com',
          'firstName' => 'John',
          'lastName'  => 'Doe',
          'phone' => '+13603963366'
      ]
      'payload' => [
          'customVariable' => 'variableValue',
          'organization' => [
            'logo' => 'https://organization.com/logo.png',
          ]
        ],
    ]);
    ```
  </Tab>
</Tabs>

## Bulk Subscriber Creation

You can create subscribers in bulk *(up to 500 at once)* via the SDKs or [API](/api-reference/subscribers/bulk-create-subscribers).

<Note> The bulk subscriber creation feature is only available in v0.19.0 and above.</Note>

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    await novu.subscribers.bulkCreate([
      {
        subscriberId: 'test-subscriber-1',
        email: 'test-user@sd.com',
        firstName: 'subscriber-1',
        lastName: 'test-1',
      },
      {
        subscriberId: 'test-subscriber-2',
        email: 'test-user-2@sd.com',
        firstName: 'subscriber-2',
        lastName: 'test-2',
      },
      {
        subscriberId: 'test-subscriber-3',
      },
    ]);
    ```
  </Tab>
</Tabs>

## Import subscribers

Here, `mock_data.csv` file is a CSV file having mock data. The below script will read this CSV file and create a new subscriber in Novu. Change example variables values like `API_KEY` value with your valid values. Download `mock_data.csv` file from [here](https://drive.google.com/file/d/159Upw30ZcPa_QnzlKF-C6_dHKDJeU-TW/view).

<Note> `mock_data.csv` file should be in the same directory of script </Note>

Steps:

1. Export your user details in CSV format.
2. Clean this exported CSV file. Keep only relevant fields.
3. Move this CSV file to the script directory.
4. Change the file name in the script with your file name.
5. Run the script. (Make script.sh executable before using)

<Tabs>
  <Tab title="Shell">
    ```shell theme={null}
    #!/bin/bash

    # Change these variables with your own values
    CSV_FILE="mock_data.csv"
    API_ENDPOINT="https://api.novu.co/v1/subscribers"
    API_KEY="ApiKey <API_KEY>"

    OLDIFS=$IFS
    IFS=','
    [ ! -f $CSV_FILE ] && { echo "$CSV_FILE file not found"; exit 99; }

    SECONDS=0

    # Read the CSV file line by line
    while read subscriberId firstName lastName email phone locale avatar
    do
        # Check if subscriberId is empty or not present
        if [[ -z "$subscriberId" ]]; then
            echo "Skipping row with missing subscriberId"
            continue
        fi

        # Construct the JSON body for the POST request
        json_body="{\"subscriberId\": \"$subscriberId\""

        # Add optional fields to the JSON body if present
        if [[ -n "$firstName" ]]; then
            json_body="$json_body, \"firstName\": \"$firstName\""
        fi

        if [[ -n "$lastName" ]]; then
            json_body="$json_body, \"lastName\": \"$lastName\""
        fi

        if [[ -n "$email" ]]; then
            # Validate email using regex
            if [[ ! "$email" =~ ^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$ ]]; then
                echo "Invalid email format for subscriberId: $subscriberId"
                continue
            fi
            json_body="$json_body, \"email\": \"$email\""
        fi

        if [[ -n "$phone" ]]; then
            json_body="$json_body, \"phone\": \"$phone\""
        fi

        if [[ -n "$locale" ]]; then
            # Validate locale using regex
            if [[ ! "$locale" =~ ^[a-zA-Z]{2}(-[a-zA-Z]{2})?$ ]]; then
                echo "Invalid locale format for subscriberId: $subscriberId"
                continue
            fi
            json_body="$json_body, \"locale\": \"$locale\""
        fi

        if [[ -n "$avatar" ]]; then
            json_body="$json_body, \"avatar\": \"$avatar\""
        fi

        if [[ -n "$address" || -n "$job" ]]; then
            json_body="$json_body, \"data\": {"

            if [[ -n "$address" ]]; then
                json_body="$json_body \"address\": \"$address\""
            else
                json_body="$json_body \"address\": \"\""
            fi

            if [[ -n "$job" ]]; then
                json_body="$json_body, \"job\": \"$job\""
            else
                json_body="$json_body, \"job\": \"\""
            fi

            json_body="$json_body }"
        fi

        json_body="$json_body}"

        echo $json_body

        #Send the cURL POST request with the JSON body and handle exceptions
        response=$(curl -s -X POST -H "Content-Type: application/json" -H "Authorization: $API_KEY" -d "$json_body" -w "%{http_code}" "$API_ENDPOINT")

        http_code=${response:${#response}-3}

        if [[ $http_code -eq 201 ]]; then
            echo "cURL request successful for subscriberId: $subscriberId - HTTP Status Code: $http_code"
        else
            echo "cURL request failed for subscriberId: $subscriberId - HTTP Status Code: $http_code - response : $response"
        fi

    done < "$CSV_FILE"

    ELAPSED="Time Elapsed: $(($SECONDS / 3600))hrs $((($SECONDS / 60) % 60))min $(($SECONDS % 60))sec"

    echo $ELAPSED
    ```
  </Tab>

  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';
    require('dotenv').config();

    const csv = require('csv-parser');
    const fs = require('fs');

    const novu = new Novu('<NOVU_API_KEY>');

    fs.createReadStream('mock_data.csv')
      .pipe(csv())
      .on('data', async (data) => {
        let subscriber = await novu.subscribers.identify(data.subscriberId, {
          email: data.email,
          firstName: data.firstName,
          lastName: data.lastName,
          phone: data.phone,
          avatar: data.avatar,
          locale: data.locale,
          data: { address: data.address, job: data.job },
        });

        console.log(subscriber.data);
      })
      .on('end', () => {
        console.log('done');
      });
    ```
  </Tab>
</Tabs>

## Delete a subscriber

To stop a subscriber from receiving notifications, you can delete the subscriber. This will hard delete the subscriber and means you will not be able to access this subscriber later. You will have to create this subscriber again.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.delete('111');
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->deleteSubscriber('111');
    ```
  </Tab>
</Tabs>

## Update a subscriber

In some cases, you want to access a subscriber to update a specific user data field or custom data field. For example, when the users change their email address or personal details.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.update('111', {
      // new email
      email: 'john@domain.com',
      // new phone
      phone: '+19874567832',
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->updateSubscriber('111', [
        // new email
        'email' => 'john@domain.com',
        // new phone
        'phone' => '+19874567832',
    ])->toArray();
    ```
  </Tab>
</Tabs>

## Find a subscriber

Any subscriber can be retrieved using a unique subscriber identifier `subscriberId`. Check the returned subscriber schema [here](#subscriber-response-schema).

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.get('111');
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->getSubscriber('111')->toArray();
    ```
  </Tab>
</Tabs>


# Topics
Source: https://v0.x-docs.novu.co/subscribers/topics



Novu offers a simple API providing an easy interface for triggering notifications to multiple subscribers at once. It is called Topics and allows the users to manage their bulk notifications without having to do complex loop implementations. A topic is identified by a custom key that is provided by the user. This custom key will be the identifier for the topic.

<Warning>
  The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.
</Warning>

Users can also assign a name to a topic. This name doesn't need to be unique and it can be changed using the API. So far, it is for descriptive goals.

A topic would get assigned different subscribers that will receive a notification every time a notification is sent to the topic.

## Create A Topic

In order to be able to send a notification to a topic, first the user needs to create one. It can be done like this:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const result = await novu.topics.create({
  key: 'unique-topic-identifier',
  name: 'descriptive-topic-name',
});
```

If successful this will return the internal Id generated by Novu and the topic key given by the user.

That topic key can be used to retrieve the whole Topic entity:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const key = 'unique-topic-identifier';

const result = await novu.topics.get(key);
```

## Rename a Topic

Descriptive name given during creation of topic can be changed later. This can be done like this:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const topicKey = 'posts:comment:12345';
const topicName = 'Post Comments';

const result = await novu.topics.rename(topicKey, topicName);
```

This will return the whole Topic information, including the subscribers if having any.

<Note>Topic Key can not be changed</Note>

## Add subscribers to a Topic

Adding subscribers to the topic is the main usecase of topic. A topic is like a group of subscribers. A notification can be sent to all subscribers of a topic at once

<Warning>
  Before adding subscribers to a topic, it's crucial to ensure that they are correctly identified in the Novu system. This identification is done using the [identify method](/subscribers/subscribers#create-a-subscriber) or API. When a subscriber is added to a topic, Novu uses the identification information to pick up the email or phone number associated with the subscriber.
</Warning>

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const topicKey = 'posts:comment:12345';

const response = await novu.topics.addSubscribers(topicKey, {
  subscribers: ['subscriber-id-1', 'subscriber-id-2', ...],
});
```

This call will return a response in the shape of:

```typescript theme={null}
{
    succeeded: ['subscriber-id-1', 'subscriber-id-2', ...],
    failed: {
      notFound: ['subscriber-id-1', 'subscriber-id-2', ...],
    },
}
```

The field `succeeded` will return the array of subscriber ids that have been correctly assigned to the topic. The field `failed` will show up only if there has been any subscriber that couldn't been assigned to the topic. This probably will happen if there is any typo in the given subscriberId or if the given subscriberId doesn't belong to the environment and the organization where the topic has been created.

### Create topic on the fly

To facilitate flows we allow to create a topic on the fly when adding subscribers.

If the topic key used does not exist for the selected environment and organization, Novu will create a new topic with name `Autogenerated-<TOPIC_KEY>` and the subscribers will be assigned to this newly created topic.

After that, that topic created on the fly can be managed in the same ways as the ones created in the normal way.

## Verify if subscriberId belongs to a topic

There would be times when it would be needed to verify if a certain subscriber belongs to a topic in order to decide what to do with that subscriber. The API call to achieve that is the following:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const externalSubscriberId = 'external-subscriber-id-1';
const topicKey = 'posts:comment:12345';

const response = await novu.topics.getSubscriber(topicKey, externalSubscriberId);
```

<Note>
  The subscriberId to use in this API call is the one used as subscriber identifier.
  The choice was made to make easier for the user to use this without making extra calls to Novu.
</Note>

## Remove a subscriber from a Topic

A single or group of subscribers can be removed from an existing topic.

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const topicKey = 'posts:comment:12345';

const response = await novu.topics.removeSubscribers(topicKey, {
  subscribers: ['subscriber-id-1', 'subscriber-id-2', ...],
});
```

Where `subscribers` will be an array of the subscriberIds we want to remove from the topic. If successful an empty response will be returned.

## Delete a topic

An existing topic can be deleted using topic-key as topic-key is the unique identifier for a topic.

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const key = 'unique-topic-identifier';

const result = await novu.topics.delete(key);
```

<Warning>
  A topic can only be deleted if it doesn't have any subscriber added. When trying to delete a topic with subscribers a conflict error will be returned. This is done to prevent accidental topic deletions.
</Warning>

## Trigger workflow to a topic

A workflow can be triggered to a single subscriber and an array of subscribers. While doing so, one need to send subscriberIds in `to` field. In case of trigger, we have already stored subscriberIds in a topic, so a topic key can be used to trigger a workflow. Workflow will be triggered to all subscribers in the topic.

```typescript theme={null}
const topicKey = 'posts:comment:12345';

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: [{ type: 'Topic', topicKey: topicKey }],
  payload: {},
});
```

## Trigger workflow to multiple topics

Workflow can be triggered to multiple subscribers by using an array of topics.

```typescript theme={null}
const topicKey = '<TOPIC-KEY-DEFINED-BY-THE-USER>';

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: [
    { type: 'Topic', topicKey: topicKey },
    { type: 'Topic', topicKey: 'Another Topic Key' },
  ],
  payload: {},
});
```

## Exclude actor from topic trigger event

To exclude the actor responsible for the action of a triggered topic event, you must add the subscriberId of that actor when triggering that event.

```typescript theme={null}
const topicKey = 'posts:comment:12345';

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: [{ type: 'Topic', topicKey: topicKey }],
  payload: {},
  actor: { subscriberId: '<SUBSCRIBER_ID_OF_ACTOR>' },
});
```

## Usecase Example

User X makes a comment, other users (A, B) who've already commented before should get a notification. So, when triggering the notification on that topic, you would usually want to exclude User X from receiving a notification about their own comment. To do that - you would need to add User X's subscriberId to the trigger event.

## API

<CardGroup>
  <Card title="Fetch list of topics" icon="plug" href="/api-reference/topics/filter-topics" />

  <Card title="Create a new topic" icon="plug" href="/api-reference/topics/topic-creation" />

  <Card title="Add subscribers to a topic" icon="plug" href="/api-reference/topics/subscribers-addition" />

  <Card title="Check if subscriber belongs to a topic" icon="plug" href="/api-reference/topics/check-topic-subscriber" />

  <Card title="Remove subscribers from a topic" icon="plug" href="/api-reference/topics/subscribers-removal" />

  <Card title="Fetch a topic by topic-key" icon="plug" href="/api-reference/topics/get-topic" />

  <Card title="Delete a topic" icon="plug" href="/api-reference/topics/delete-topic" />

  <Card title="Rename a topic" icon="plug" href=" /api-reference/topics/rename-a-topic" />
</CardGroup>

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="Does it mean that all subscribers of one topic have same preference">
    No, adding subscribers into topic does not change subscriber's individual [subscriber preference](/subscribers/preferences). Topic is mainly used to group subscribers and fan out workflow triggered notifications to all subscribers at once.
  </Accordion>
</AccordionGroup>


# Tenants
Source: https://v0.x-docs.novu.co/tenants/introduction

Learn all about Tenants

Multi-tenancy is a common use case for a lot of companies that have multiple organizations that use their applications. In some cases, there is a need to separate the behavior of the notification system depending on the individual tenants.

Currently, Novu supports the following customizations:

* Workflow level customizations
* Integration customizations

## Tenant Management

Tenants can be created and modified via the [API](http://docs.novu.co/api-reference/tenants/get-tenants) or [Web](https://web.novu.co/tenants?utm_campaign=docs-tenants). Each tenant can have multiple fields on it:

* Identifier - The identifier is a unique value, and can be used later when pointing to this tenant during trigger calls.
* Name - A human-readable name of the tenant.
* Data - A custom data object that can store information about the tenant. This data can be later accessed inside workflows.

To create a tenant on the Novu web platform, follow these steps:

* Click on `Tenants` on the left sidebar.
* In the Tenants section, click on the `Add a tenant` button.
* Set a `Name` and `Tenant identifier`. The tenant identifier is automatically set once you add a name. However, you can modify it to your needs.
* Set a JSON-format `Custom properties` (optional).

## Workflow Level Customizations

When triggering a workflow, it is possible to pass the tenant information (id or object, in case of an object, novu will upsert the tenant if it’s not existing) like so:

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
      import { Novu } from '@novu/node';

      const novu = new Novu("<NOVU_API_KEY>");

      await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
        {
          to: {
            subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          },
          payload: {
            name: "Hello World",
          },
          actor: "actorId"
          tenant: "tenantIdentifier"
        }
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
      use Novu\SDK\Novu;

      $novu = new Novu('<NOVU_API_KEY_HERE>');

      $novu->triggerEvent([
        'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
        'payload' => [
          'name' => 'Hello'
        ],
        'to' => [
            'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
        ],
        'actor': "actorId"
        'tenant': "tenantIdentifier"
      ]);
    ```
  </Tab>
</Tabs>

The tenant information can now be used inside the workflow template in the following way:

```
{{ tenant.data.customProp }}
```

## Workflow Settings Override

Workflow settings can now be updated on the workflow per tenant. This enables each tenant to have unique preferences that doesn't affect others within the same workflow.

The `active` and `channel` preferences fields of a workflow can be updated to be tenant-specific the [workflow-overrides API endpoint](/api-reference/workflow-overrides/create-workflow-overrides).

<Warning>This feature is only available from v0.22.0.</Warning>

## Integration Level Customizations

When creating an integration, you can create a condition where you can specify a delivery provider for a channel when a particular tenant id is matched.

The delivery provider specified will only be used if the trigger is executed with the tenant id.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Tenant-specific Notification Content

When creating a step, variants could be created for each step including digest and delay. For each variant, conditions set can be applied on when this variant could be used.

Using so different workflow configurations (for example digest duration) could be configured on the individual workflow for a given tenant.

For example, if you want a specific notification content to be sent to a tenant named "JohnDoe", and another to be sent to others. You can do the following:

* Create an email step in your workflow
* In the email step workflow, click on the "Add variant" icon at the top right to add a new variant.

<Frame>
  <img />
</Frame>

* It opens up the condition page. Set the tenant identifier to equal "JohnDoe".

<Frame>
  <img />
</Frame>

* Apply Conditions as shown above.
* Check the email step in the workflow, you'll see the **root variant** and **v1 variant**.

<Frame>
  <img />
</Frame>

Once a trigger runs, the Novu engine checks to see if there's a `tenant` identifier specified in the trigger code.

An example of the trigger code:

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
      import { Novu } from '@novu/node';

      const novu = new Novu("<NOVU_API_KEY>");

      await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
        {
          to: {
            subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          },
          tenant: "JohnDoe"
        }
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
      use Novu\SDK\Novu;

      $novu = new Novu('<NOVU_API_KEY_HERE>');

      $novu->triggerEvent([
        'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
        'to' => [
            'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
        ],
        'tenant': "JohnDoe"
      ]);
    ```
  </Tab>
</Tabs>

* If it exists, a condition check is done to see if there's a variant that matches the tenant identifier.
* If there's a match, the specific variant template will be fired.
* If there's no match, the root variant template will be fired.

It is also possible to use handlebars to have minor tenant adjustments in a single step:

```
<img src="{{tenant.data.logo}}" />
```

<Warning> For self-hosted users, this is only available from version 0.22.0. </Warning>


# Delay Action
Source: https://v0.x-docs.novu.co/workflows/delay-action

More on how Delay Action Node works

The delay action awaits a specified amount of time before moving on to trigger the following steps of the workflow.

### Delay Action Node

After adding a delay node in the workflow editor, the immediate next step will only be triggered after the specified period of time has elapsed.

# Configurations

## Regular Delay

Regular Delay will determine how long it will take before triggering the next step.

## Time Interval

You can specify the amount and time unit that best suits your needs.

Should you wish to, you could override the default delay time interval you set in the creation of the delay node.

```tsx theme={null}
novu.trigger('template-name', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>'
  },
  payload: {
    name: 'Hello',
  },
  overrides: {
    delay: {
      unit: 'days',
      amount: 2,
    },
  },
});
```

## Scheduled Delay

Scheduled Delay allows delaying up to a future date before continuation of steps execution. All steps after delay node will be triggered only after said date.

### Payload Path[](https://docs.novu.co/platform/delay#payload-path)

Payload path will determine the path in payload for the scheduled date.

That path must be included in your payload on trigger execution and must be a date in strict ISO format.

For example:

<img />

```tsx theme={null}
novu.trigger('workflow-name', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>'
  },
  payload: {
    sendAt: '2022-09-21T10:48:44.388Z',
  },
});
```

<Note>
  Date must be in ISO date format of YYYY-MM-DDThh:mm:ss.SSSZ
</Note>


# Digest Engine
Source: https://v0.x-docs.novu.co/workflows/digest

Deep dive into Digest functionality

The digest engine collects multiple trigger events, aggregates them into a single message and delivers it to the subscriber.

This becomes useful when a user needs to be notified on a large amount of triggers and you want to avoid sending too many notifications. Novu will automatically batch the incoming trigger events based on the `subscriberId` and an **optional** `digestKey` that can be added to control the digestion of the events.

### Digest Node

After adding a digest node in the workflow editor, each node that will be below the digest node will be only triggered once in the specified digest interval. You can decide to send messages before adding a digest node and they will be triggered in real-time.

<Frame>
  <img />
</Frame>

In the image above, there are two nodes (`Email` and `SMS`) after the digest node and one node (`In-App`) before the digest node in the workflow.

For this workflow, if we trigger 10 events within the digest interval, the `In-App` step will be executed 10 times, and `Email` and `SMS` will be executed only 1 time with digested events data.

## Digest Configuration

### 1. Digest Key

If specified, the digest engine will group the events based on the `digestKey` and `subscriberId`, otherwise the digest engine will group the events based only on the subscriberId.

The digest key might come useful when you want a particular subscriber to get events grouped on a custom field. For example when an actor likes the user's post, you might want to digest based on the `post_id` key.

<Frame>
  <img />
</Frame>

### 2. Time Interval

The time interval determines how long the digest engine will wait before sending the message once created. You can specify the amount and the unit that best suits your needs.

Here, in the image below, `5` is the interval amount, and `mins` is the interval unit. Interval units can be `sec(s)`, `min(s)`, `hour(s)`, or `day(s)`.

<Frame>
  <img />
</Frame>

## Digest Strategy Types

The strategy which Novu should use to handle the digest step. More details on available strategies below.

Novu allows you to define different digest strategies depending on the actual use-case you are trying to achieve. At this point we allow you to select from 2 strategies:

* Regular Strategy
* Back-off Strategy

Let's explore them in detail:

#### Regular Strategy

In regular strategy, a digest will always be created for the specified window time. Which means that from the first event trigger, if no active digest exists for this subscriber, one will be created and the user will receive the message only when the digest window time is reached.

#### Back-off Strategy

In the back-off strategy, before creating a digest, Novu will check if a message was sent to the user in the back-off period. If a message was sent, a digest will be created. Otherwise, a message will be sent directly to the user and the digest creation will be skipped.

Backoff digest has two intervals, `digest interval` and `backoff interval`. Here, in the image below, the `digest interval` is `20 minutes`, and the `backoff interval` is `15 minutes`. In the case of a backoff digest, first, it checks if any event is triggered within the past backoff interval, only then a digest is created for the digest interval. If not, the event is considered non-digest and workflow execution continues to the next step.

<Frame>
  <img />
</Frame>

**Example:**

Let's set the digest interval as 20 minutes and the backoff time as 15 minutes.

If we trigger the first event. Since it is the first event and there was no event triggered in the past 15 minutes (backoff interval), this event will be executed as it is (without digest).

Now, if we trigger a second within 15 minutes, then a new digest will be created with this second event. From now onwards till 20 minutes (digest interval), all triggers will be digested in this digest, and after 20 minutes, the workflow will carry forward to the next step with digested events.

## Scheduled Digest

**Minutes:**

It digests events for every specified minutes. For example, as per the image below, events will be digested for 20 minutes and after 20 minutes, workflow will carry forward to the next step. It will be repeated after every 20 minutes.

<Frame>
  <img />
</Frame>

**Hour:**

It digests events for given hours. After given hours, a new digest is created.

<Frame>
  <img />
</Frame>

**Daily:**

It digests events for specified days till given time. After those days and time, a new digest is created and events are digested in this new digest.

<Frame>
  <img />
</Frame>

**Weekly:**

It digests events for specified weekdays. Only at the specified time, the workflow continues to the next step after the digest step. A new digest is created and events are digested in this new digest till these weeks and time.

<Frame>
  <img />
</Frame>

**Monthly:**

<Frame>
  <img />
</Frame>

## Writing digest templates

In many cases, you will need to access all the digested events payload in order to show the user all or parts of the events included in this digest. For example: **"John and 5 others liked your photo."**

As part of the digested template, you will have access to a few properties:

| Property           | Description                                                                                                                                       |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| `step.events`      | An array of all the events aggregated under this digest. This will be the "payload" object passed to each trigger.event sent in the digest period |
| `step.total_count` | The number of total events in this digest                                                                                                         |
| `step.digest`      | A boolean flag to indicate if we are in a digest mode right now                                                                                   |

Let's look at a handlebars syntax example for the following triggers:

```tsx theme={null}
novu.trigger('workflow-name', {
  to: '123',
  payload: {
    name: 'Hello',
  },
});

novu.trigger('workflow-name', {
  to: '123',
  payload: {
    name: 'World',
  },
});
```

After these two triggers, digest variables are as follows:

| Property           | Description                                     |
| ------------------ | ----------------------------------------------- |
| `step.events`      | `[ { "name" : "Hello" }, { "name": "World" } ]` |
| `step.total_count` | `2`                                             |
| `step.digest`      | `true`                                          |

Using the following template:

```HTML theme={null}
Total events in digest:
{{step.total_count}}

{{#if step.digest}}
  {{#each step.events}}
    {{name}}
  {{/each}}
{{else}}
  Not a digested template
{{/if}}
```

It will render as:

`Total events in digest: 2 This is Hello payload event This is World payload event`

<Note> Note that if only one matching trigger activates a regular digest during its period, that single item will still come through as a digest with `step.total_count` as 1. </Note>

### Using subscriber variables

Subscriber variables like `{{subscriber.firstName}}` , `{{subscriber.email}}` etc are system reserved variables. These variables can be used in the same form if used outside of `step.events` iteration. If you want to use subscriber variables inside `step.events` iteration, you can use `{{../subscriber.firstName}}` , `{{../subscriber.email}}`. Reason of this change inside `step.events` iteration is the context change. Subscriber variables are available in the parent context of `step.events` iteration.

```HTML theme={null}
Total events in digest:
{{step.total_count}}
Hey, {{subscriber.firstName}} your id is {{subscriber.subscriberId}}
{{#if step.digest}}
  {{#each step.events}}
    {{name}}
    <br/>
    {{../subscriber.firstName}} your email is {{../subscriber.email}}
  {{/each}}
{{else}}
  Not a digested template
{{/if}}
```

## Event cancellation from Digest

Any event can be cancelled from the Digest via the [event cancellation API](/api-reference/events/cancel-triggered-event) using transactionId of triggered event. For example, if there are 5 events in digest, a user should be able to cancel the **2nd**, **3rd**, or **4th** event before digest time completion.

The cancelled event will not be included in the final digest events array.

## Digest Guides

<CardGroup>
  <Card title="Add Digest to Email Notifications" icon="envelope" href="/guides/add-digest-to-email-notifications">
    Learn how to add digest functionality to email notifications.
  </Card>

  <Card title="Add Digest to In-App Notifications" icon="bell" href="/guides/add-digest-to-inapp-notifications">
    Learn how to add digest functionality to a In-App feed within React app.
  </Card>
</CardGroup>

## Frequently Asked Questions

<Note>All digest times are in UTC time</Note>

<AccordionGroup>
  <Accordion title="If scheduled digest is set for 9:00 AM daily then will the digest be sent at 9:00 AM every day without any event triggered?">
    If scheduled digest is sent for 9:00 daily, then novu will collect all events triggered between 9:00 AM today till 9:00 AM tomorrow and send the digest at 9:00 AM tomorrow. This process is repeated daily. If there is no any event triggered between 9:00 AM today and 9:00 AM tomorrow, then no digest will be sent.
  </Accordion>

  <Accordion title="What is the difference between Regular and Schedules Digest set to 1 Hour?">
    Both digests are same in this case.
  </Accordion>
</AccordionGroup>


# Messages
Source: https://v0.x-docs.novu.co/workflows/messages

Learn about messages in Novu

Each [workflow](/workflows/notification-workflows) has one or more than one step. Each step is either a `channel` (in\_app, email, push, chat) or an `action` (digest, delay).

Within the workflow, every channel has a separate template. Email channel step content can be different than `in_app` channel step content. When a workflow is triggered, Novu generates separate messages for every channel step and sends that message to the recipient.

A triggered event (`notification`) is a collection of step information, its message, and job execution details.

## List messages

Messages can be listed using these SDK methods. These methods support pagination using page and limit field and filters using channel, subscriberId and transactionId field.

<Info>Novu will throw 404 error if requested subscriberId is not a valid subscriberId of any existing subscriber.</Info>

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu, ChannelTypeEnum } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.messages.list({
      page: 0,
      limit: 30,
      channel: ChannelTypeEnum.IN_APP,
      subscriberId: '<SUBSCRIBER_ID>'
      transactionIds: ['transactionId1', 'transactionId2'],
    });
    ```
  </Tab>
</Tabs>

### List messages example response

```javascript theme={null}
{
  "page": 0,
  "totalCount": 987,
  "hasMore": true,
  "pageSize": 30,
  "data": [
    ....
    {
      "cta": {
          "action": {
              "buttons": []
          },
          "type": "redirect",
          "data": {
              "url": ""
          }
      },
      "_id": "messageId",
      "_templateId": "workflowId",
      "_environmentId": "environmentId",
      "_messageTemplateId": "messageTemplateId",
      "_notificationId": "notificationId",
      "_organizationId": "organisationId",
      "_subscriberId": "_subscriberId",
      "_jobId": "jobId",
      "templateIdentifier": "workflowIdentifier",
      "_feedId": "feedId",
      "channel": "in_app",
      "content": "Message Content",
      "deviceTokens": [],
      "seen": false,
      "read": false,
      "status": "sent",
      "transactionId": "d5218a6c-4b08-4617-b176-2d2271f34e42",
      "payload": {
          "key": "value"
          "__source": "test-workflow"
      },
      "expireAt": "2024-06-17T08:18:29.871Z",
      "deleted": false,
      "createdAt": "2023-06-17T08:18:29.871Z",
      "updatedAt": "2023-06-17T08:24:34.888Z",
      "__v": 0,
      "subscriber": {
          "_id": "_subscriberId",
          "subscriberId": "subscriberId",
          "id": "_subscriberId"
      },
      "actorSubscriber": 'actorSubscriberId',
      "id": "messageId"
    }
    ....
  ]
}
```

## Delete a message

A single message can be deleted by messageId using these SDK methods. messageId should be a valid objectId parsed as a string.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    const messageId = '64452b58ec0dbb9e41b4dccf';

    await novu.messages.deleteById(messageId);
    ```
  </Tab>
</Tabs>

### Delete a message example response

```javascript theme={null}
{
  data: {
    acknowledged: true,
    status: 'deleted'
  }
};
```

## API Reference Links

* [List Messages API](/api-reference/messages/get-messages/)
* [Delete a Message API](/api-reference/messages/delete-message/)


# Workflows
Source: https://v0.x-docs.novu.co/workflows/notification-workflows

Here you learn all about workflows

A workflow holds the entire flow of steps (nodes) that are sent to the subscriber. This is where all the different channels are tied together under a single entity.

<Note>
  Notification template has been renamed to workflow. Previously, workflow has been referred to as notification template.
</Note>

## Structure

A workflow acts as the blueprint for the notifications that will be sent. The workflow encapsulates the entire flow and rules of messages that are being sent. This is where all the different channels, filters, rules and actions are tied together under a single entity.

<img />

## Workflow Components

<Steps>
  <Step title="Name and Identifier">
    Every workflow will have a name and an identifier that are used to uniquely identify each workflow.
  </Step>

  <Step title="Trigger">
    The "Trigger" refers to an event or action that initiates the workflow. It signifies a call to the Novu API with a specified workflow ID, along with the necessary payload data that the workflow content will utilize.
  </Step>

  <Step title="Channels">
    In Novu, a channel refers to a preconfigured provider through which notifications are dispatched to recipients. In most instances within Novu, these channels utilize the credentials you provide to ensure the delivery of notifications on your behalf. The combination of these credentials and accompanying settings constitutes a configured channel.

    Within the Novu framework, channels are categorized into various types, each of which is linked with at least one corresponding provider that can be tailored as needed:

    * **Email** (examples include Sendgrid, Postmark)
    * **In-App** (such as feeds, toasts, banners)
    * **Push** (such as APNS, FCM)
    * **SMS** (examples include Twilio, Telnyx)
    * **Chat** (such as Slack, Microsoft Teams, and Discord)
    * **Webhook** (used to send webhooks to custom channels or enable your customers to configure webhooks within your product)
  </Step>
</Steps>

## Execution of Workflow Steps

Once a workflow is initiated by its trigger, the steps (and channels) within the workflow are executed in a specific sequence. This sequential execution ensures that each step is completed before the next one begins, maintaining a controlled and orderly flow of the notification process. Here's what you need to know about this process:

* **Sequential Execution:** Each channel in the workflow is activated one after the other, in the order they are listed within the workflow. This method ensures that each step is given the necessary attention and that dependencies or prerequisites of later steps are adequately met.

* **Order of Channels:** The order in which channels are listed in the workflow is crucial, as it dictates the sequence of their execution. You should carefully consider the order when setting up your workflows to align with your notification strategy.

Sequential execution provides a predictable and reliable workflow process, ensuring that messages are sent out in an organized manner and that each step's output potentially influences the subsequent ones.

<br />

<Warning>Once a workflow is triggered, it can not be changed.
<br /> <br /> Workflow can be canceled only using  [DELETE /events/cancel api](/api-reference/workflows/delete-workflow)</Warning>

<Note>Subscriber is not allowed to manage subscriber preference for [critical workflow](/subscribers/preferences#exclude-workflows-from-preferences-critical-workflow)</Note>

## Workflow Groups

Workflow groups are used to categorize workflows based on their purpose or function. This grouping allows you to organize your workflows in a way that makes sense to you and your team. For example, you may want to group all your onboarding workflows or group all your transactional workflows together. You can create as many groups as you need and assign workflows to them as you see fit.

<Info>Currently workflow group is just for reference purposes and cannot be used for bulk action related to all workflows belonging to a workflow group.</Info>

### Working with workflow groups

**To create a workflow group, follow these steps:**

1. Navigate to the **Workflows** page in the Novu interface.
2. Select any workflow from the list.
3. Click on the **cog** icon on the top right side to open the workflow settings.
4. Stay on the *General* settings tab.
5. Click on the **Workflow Group** dropdown and select the group you want to assign to the workflow.
6. To create a new group start writing some text and a **Create New** option will appear. Click on it to create a new group and select this group for this workflow.
7. Click on the update button on the top right side to save the changes for the entire workflow.

<Frame>
  <img />
</Frame>

To edit a workflow group name, follow these steps:

1. Navigate to the **Settings** page in the Novu interface.
2. Copy the **API Key** from settings (Each environment has a different API Key).
3. Navigate to [API Reference](https://docs.novu.co/api-reference/workflow-groups/get-workflow-groups) page to fetch all workflow groups in Novu documentation.
4. Use the previously copied **API Key** as the **Authorization** header. Make sure it is in the correct format `ApiKey <API_KEY>`
5. Click on the send button to fetch all the workflow groups.
6. In the response field copy the **\_id** field of the workfow group that you want to edit.
7. Use the copied **\_id** as the **path parameter** in the request URL of [workflow update](https://docs.novu.co/api-reference/workflow-groups/update-workflow-group) API using the same **API Key** as the **Authorization** header. Write the new name for the group in the **body** field.
8. Click on the send button to update the workflow group name.

<Info>To delete the workflow group use [delete workflow group api](https://docs.novu.co/api-reference/workflow-groups/delete-workflow-group) with the same steps as updating the workflow group name. However, it is not recommended to delete the workflow group if at least one workflow is attached to this workflow group or there exists a change promotion item on the changes page</Info>

## Searching Workflows

Workflows can be searched by their name or trigger identifier. This feature makes it easy to find the desired workflow and quickly access its details.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## FAQs

<AccordionGroup>
  <Accordion title="Workflow Promotion Error: Notification Group Id Not Found">
    To address the error "Notification Group Id not found" when promoting the workflow from dev to prod, it's essential to check the allocation of a notification group to the workflow. Here is an outlined process to validate:

    <Steps>
      <Step title="Go to the workflow settings in Novu's interface." />

      <Step title="Remain within the general settings tab." />

      <Step title="Check the right-hand side for the notification group dropdown." />

      <Step title="Verify if any group is selected. The group's association will be demonstrated here." />
    </Steps>

    <Tip>New notification group can also be created in the drop-down</Tip>

    If a notification group is not associated, this is likely the cause of the issue. Ensure that the relevant Notification Group Id is assigned in the settings. To do so, you would need to choose one from the drop-down list in the workflow settings .

    <Frame>
      <img />
    </Frame>

    Remember, deleting a workflow is not recommended because it can lead to unexpected behavior like this. Instead, updating the workflow group associated with the specific workflow is the right process to address the issue.
  </Accordion>

  <Accordion title="How to disable a workflow for a single subscriber?">
    When all channels are turned off for that subscriber then subscriber will not receive any messages from any channel step, effectively disabling the workflow for that subscriber.

    2. If you want to make a workflow inactive or active, you can do so through the workflow settings. However, it's important to note that this action will affect **all** subscribers.

    3. To disable a workflow for only one subscriber, you can achieve this by having the subscriber disable all channels for that specific workflow through their subscriber preferences. This action will solely impact that particular subscriber.
  </Accordion>

  <Accordion title="What is the difference between workflowId and trigger identifier?">
    `workflowId` is a MongoDB-generated identifier within the Novu system, serving as a unique identifier for workflows. It cannot be modified or altered once generated. This `workflowId` is utilized in several APIs, including the [GET Workflow API](https://docs.novu.co/api-reference/workflows/get-workflow).

    <img />

    A `trigger identifier` is a distinctive label utilized to activate a workflow, typically represented in a slugified format. Novu generates this identifier automatically based on the workflow's name, and it can be modified at a later time if needed. Currently, our system supports only a single trigger identifier per workflow. However, as part of our future plans, we intend to enable the use of multiple trigger identifiers for a single workflow, each capable of initiating the workflow from different sources.

    <img />

    Hence, while `workflowId` refers to the umbrella structure that holds the entire flow of messages, the `trigger identifier` is the specific event that starts this sequence.
  </Accordion>

  <Accordion title="How does Novu prevent duplicate notifications sent to subscribers?">
    The `transactionId` within Novu is a unique identifier that is used to ensure the idempotent nature of notification delivery.

    When you trigger an event to send a notification, you have the option to provide a `transactionId`. If you do not provide one, Novu will generate a UUID for you.

    **This identifier is particularly useful for preventing the same notification from being sent multiple times in case the trigger event is inadvertently called more than once.**

    By leveraging the `transactionId`, you can make idempotent requests, which means if the same `transactionId` is used in another request, Novu's API will recognize it and will not send the same notification again.

    <Note>
      This upholds the principle of idempotency, ensuring that the effect of the operation is the same, no matter how many times the request is repeated with the same `transactionId`.
    </Note>
  </Accordion>
</AccordionGroup>


# Step Conditions
Source: https://v0.x-docs.novu.co/workflows/step-filters

Learn how to customize your notifications flow in Novu.

Workflow step conditions allow you to customize the flow of notifications in your workflow by specifying criteria for which notifications should be delivered.

You can use these conditions to ensure that only relevant notifications are sent to your subscribers, improving the efficiency and effectiveness of your communication.

<Warning>**Step Conditions** used to be called **Step Filters**.</Warning>

## On Condition

* On `payload`: You can specify a list of keywords or values that the `payload` field must match in order for the notification to be delivered. This is useful if you only want to receive notifications that contain certain information.
* On `subscriber`: You can filter which subscriber should receive notifications based on subscriber information. This means that you can send notifications to specific individuals or groups rather than all subscribers. It checks on subscriber attributes. Read more about [subscriber attributes](https://docs.novu.co/subscribers/subscribers#subscriber-attributes).
* On `webhook`: You can use this feature to provide information about subscribers from specified webhook response and use that information to filter the notification flow. For example, if your webhook returns a field indicating whether a subscriber is currently online, you can use this field to send notifications only to online subscribers.
* On `online right now`: You can filter notifications on the basis of the current online status of the subscriber. For example, You can choose to send a notification if the subscriber is currently online or offline.
* On `online in the last "X" time period`: You can use this to filter notifications for a subscriber if the subscriber was online in the last `X` minutes/hours/days.

### Steps to set Conditions

1. Create a step in your workflow. This step will be the location where you will apply your filter.
2. Add a condition to the step. This will allow you to specify the criteria that must be met for the notification to be delivered.

<Frame>
  <img />
</Frame>

3. If you want to add multiple conditions, you will need to choose a logical condition between `AND` and `OR` . This will determine how the conditions are applied to the notification. For example, if you choose `AND`, the notification will only be delivered if all of the conditions are met. If you choose `OR`, the notification will be delivered if any of the conditions are met.
4. Add a rule to the condition. This will specify the criteria that must be met for the notification to be delivered. You can use the `payload`, `subscriber`, or `webhook` field as the basis for your rule. For example, you might specify that the `payload` field must contain a certain keyword or that the `subscriber` must be in a specific group.

## Condition rule

A condition rule is composed of the following fields:

* **On** : This specifies which field the rule should be applied to, such as `Payload`, `Subscriber`, or `Webhook` response.
* **Key** : This specifies the object key that the rule should be applied to. For example, if the `On` field is `Subscriber`, the `Key` field might be `name`, `email` etc.
* **Operator** : This specifies the comparison operator to use when evaluating the rule. Options include **Equal**, **Not equal** , **Larger** , **Smaller** , **Larger or equal**, **Smaller or equal** , **Contains**, **Not contains** and **Is Defined**.
* **Value** : This specifies the `value` to compare to the object key value using the selected `operator`. The value field also accepts variables.

<Frame>
  <img />
</Frame>

**Example of a condition rule**:

In this condition, the notification will only be delivered if the webhook response includes a field called `isOnline` that is set to `true`.

<Frame>
  <img />
</Frame>

## Conditions with Webhook

To filter notifications based on a webhook response, you will need to create a webhook that accepts POST requests and returns a one-level object. The webhook should be set up to receive object the following parameters:

* **subscriber** - This is an object containing information about the subscriber that the notification is being sent to.
* **payload** - This is an object containing the payload of the trigger that initiated the notification.
* **identifier** - workflow identifier is a unique identifier for the notification template being used.
* **providerId** - provider identifier is a unique identifier for the communication provider you used on this notification.
* **channel** - The channel identifier specifies the type of notification channel that was used to send the notification.

### Securing your webhooks

To secure your webhooks, Novu uses the `nv-hmac-256` header as a security measure.

This header contains an HMAC hash that is calculated based on your `API Key` 
and `Environment Id`, ensuring that the request is coming from Novu.
This helps in protection against unauthorized access and tampering with your webhooks.

To verify the authenticity of the request, you can use the following code:

```jsx theme={null}
import { createHmac } from 'crypto';

const hmacHash = createHmac('sha256', 'NOVU_API_KEY').update('ENVIRONMENT_ID').digest('hex');

if (hmacHash === hmac) {
  // The request is authentic
} else {
  // The request is not authentic
}

```

> **ENVIRONMENT\_ID** can be accessed in the webhook subscriber parameter in the request body. **NOVU\_API\_KEY** can be found in the settings section of the Novu client.

The webhook should return a one-level object containing any information that you want to use to filter the notification flow. For example, you might include a field called `isOnline` having value `true` or `false` that specifies whether the subscriber is currently online or not.

## Subscriber online conditions

This allows you to apply a condition on a workflow step based on the `subscriber's` online status. The condition can be applied to determine if the subscriber is currently online or if the subscriber was online in the **X** time-period.

**Example** : To send an email notification to all subscribers who were active within the last 30 minutes, follow these steps:

* On the Workflow editor page, add an `Email` step after trigger in workflow.
* Click on the email step to edit its content template.
* Click on the  `Add conditions` button from the upper right position.

<Frame>
  <img />
</Frame>

* Click `Add condition` to add a rule.
* Select `Last time was online` and choose `minutes` as the time period.
* Enter `30` in the input field.

<Frame>
  <img />
</Frame>

By applying this condition, the notification will only be delivered to subscribers that were last active in the past 30 minutes, ensuring that the message is reaching engaged and active recipients.

### Online condition mechanism

Novu uses a websocket connection within the `notification-center` package to track the online status of subscribers. The `isOnline` and `lastOnlineAt` fields of the subscriber's entity are updated accordingly.

When a subscriber comes online, an active websocket connection is established with the server. Novu then updates the `isOnline` field of the subscriber's entity to `isOnline: true`. When the subscriber disconnects, Novu updates `isOnline: false` and `lastOnlineAt: current_timestamp`.

The online condition feature can be used to determine if a subscriber is online right now or if the subscriber was online within a specific time period.

* To determine if a subscriber is online right now, Novu checks the value of the `isOnline` field. If `isOnline` is `true`, the subscriber is online, otherwise when the `isOnline` is `false` the subscriber is considered offline.
* To determine if a subscriber was online within a specific time period, Novu compares both the `isOnline` and `lastOnlineAt` fields. If `isOnline` is `true`, the subscriber is still online and the condition is applied. If `isOnline` is `false`, the difference between the `current timestamp` and the `timestamp` value of `lastOnlineAt` is calculated. If this difference is within the specified time period, the subscriber was online within that time period and the condition is applied. Otherwise, the condition is not applied.

For example, to determine if a subscriber has been online in the last 5 minutes, Novu checks if the subscriber is currently online or if the `lastOnlineAt` timestamp value is less than or equal to 5 minutes ago. If either of these conditions are met, the condition is applied.

## Subscriber Seen / Read Conditions

This condition gives the flexibility of executing successive step notifications based on the status of previous step notification. It currently works for in-app and email step notifications.

**Typical Use Case**:

You have a set of customers to whom you need to send a 2-step email. However, they should only get the second email if they have read/seen the first email.

With the seen/read condition, you can do the following in a workflow:

* Set the first email step.
* Set a delay.
* Set the second email step.
* Create a condition on the second email step that indicates if the previous step needs to be seen/read before it should be executed.

<Frame>
  <img />
</Frame>

<Note> For this condition to work with emails, the webhook url needs to be set up for the active `email` provider you're using on Novu. It's very essential for the condition to work. No extra set up is needed for `in-app` notifications. </Note>

## Is Defined Condition

Is Defined condition checks whether specified `key` exists or not. It is different from `Equal` and `Not equal` condition. `Equal` and `Not equal` condition checks whether key value is equal to specified value or not, but `Is Defined` condition just checks whether key is present or not.

<Frame>
  <img />
</Frame>

<Note> This condition can be used with subscriber, payload and webhook. It can be applied on all channels. </Note>

## Monitoring the condition's status inside Activity Feed

To check if the notification sent was conditioned or not, visit the `Activity Feed` page.

* Select the notification you're interested in checking the filter status for.
* A new popup `Execution Details` will open up.

<img />

* Click on the notification step row to open up the details for the corresponding step.
* On this screen, you can monitor the notification status along with filter details if any.

<img />

<Info>Digest variables (step.digest, step.events, step.total\_count) are not supported in step conditions.</Info>


# Template Store
Source: https://v0.x-docs.novu.co/workflows/template-store

Display inline code and code blocks

The Novu dashboard features an integrated template store for workflows, offering a range of ready-to-use options.

From basic alerts to intricate sequences, you can select a template, customize it, and swiftly trigger notifications tailored to your needs.
This streamlined process cuts down development time and empowers you to communicate effectively with minimal effort.

<img />


# Variants
Source: https://v0.x-docs.novu.co/workflows/variants

Learn how to create and use multiple variants for workflow steps in Novu.

Variants is a workflow component that empowers users to create multiple versions of a given workflow step.

You can use variants to ensure that only specific versions of your workflow step (e.g Email) are sent to subscribers. These variants are linked to specific conditions. No variant can exist without a condition.

Variants are an integral component of our [multi-tenancy feature](/tenants/introduction#tenant-specific-notification-content).

## Steps to create Variants

In this case, we'll use a workflow Email step. Let's create multiple variants for this step.

1. Create an email step in your workflow.

<Frame>
  <img />
</Frame>

2. Add a variant to the step as shown below.

<Frame>
  <img />
</Frame>

3. A variant must have conditions set. Add a condition or multiple conditions.

<Frame>
  <img />
</Frame>

In this case, we added a condition (as shown below) to check if the tenant identifier passed at the point of trigger is equal to `edenlife`. This is now a **multi-tenant variant**!

Apply conditions to set it successfully.

<Frame>
  <img />
</Frame>

The variant has been created. Click on the **Update** button.

<Frame>
  <img />
</Frame>

4. Head over to the email step again. You will see two variants: the **root variant** & **v1 variant**. The **v1 variant** is the one where you set the tenant condition while the **root variant** is the default version of the email step without a condition.

<Frame>
  <img />
</Frame>

5. You can add different content to the two variants.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

During the notification sending phase, Novu's logic will determine the appropriate variant based on the contextual information that was passed with the trigger event and the conditions applied to the variants.

In this case, if a tenant identifier with the value of `edenlife` was passed with the trigger event, then Novu will select the v1 variant and send to subscribers.

On the other hand, if the tenant identifier has a different value or was not passed with the trigger event, then Novu will select the root variant and send to subscribers.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
      import { Novu } from '@novu/node';

      const novu = new Novu("<NOVU_API_KEY>");

      await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
        {
          to: {
            subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          },
          payload: {
            name: "Hello World",
          },
          tenant: "edenlife"
        }
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
      use Novu\SDK\Novu;

      $novu = new Novu('<NOVU_API_KEY_HERE>');

      $novu->triggerEvent([
        'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
        'payload' => [
          'name' => 'Hello'
        ],
        'to' => [
            'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
        ],
        'tenant': "edenlife"
      ]);
    ```
  </Tab>
</Tabs>

## Variant Conditions

There are so many use cases for variants. It's not limited to [multi-tenancy](/tenants/introduction#tenant-specific-notification-content).

You can set conditions based on the following data:

* Subscriber
* Payload
* Webhook
* Is online
* Last time was online

### Sample Use Cases

1. If you're looking to send a different type of email based on whether a subscriber is online, then variants are the right choice.

2. If you want to send different types of email to subscribers based on the specific type of payload or subscriber data passed with the trigger event, variants are a good choice!


# Data Migrations
Source: https://v0.x-docs.novu.co/additional-resources/data-migrations

Learn how to update your database data through migrations.

On occasion, Novu may introduce features that require changes to the database schema or data.
This usually happens when a feature has a hard dependency on some data being available on a database entity.
You can use migrations to make these changes to your database.

## Running Migrations

To run data migrations, enter the following sequence of commands in your terminal from the [`novuhq/novu`](https://github.com/novuhq/novu) repository root:

```bash theme={null}
npm run setup:project
cd apps/api
npm run migration -- ./migrations/<MIGRATION_PATH>.ts
# e.g. npm run migration -- ./migrations/add-user-contact/add-user-phone.ts
```

Some features may have multiple migrations, in which case you will need to run each migration in the order shown below.

## Migrations History

Below you will find a list of migrations introduced in previous versions of Novu, alongside the migration path to use in the script above.

| Version                                                      | Feature                 | Migration Path(s)                                                                                                                          |
| ------------------------------------------------------------ | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| [v0.23](https://github.com/novuhq/novu/releases/tag/v0.23.0) | API keys encryption     | `./encrypt-api-keys/encrypt-api-keys-migration.ts`                                                                                         |
| [v0.18](https://github.com/novuhq/novu/releases/tag/v0.18.0) | Multi-Provider          | `./integration-scheme-update/add-primary-priority-migration.ts`<br />`./integration-scheme-update/add-integration-identifier-migration.ts` |
|                                                              | Integration Store       | `./novu-integrations/novu-integrations.migration.ts`                                                                                       |
| [v0.16](https://github.com/novuhq/novu/releases/tag/v0.16.0) | In-App Integration      | `./in-app-integration/in-app-integration.migration.ts`                                                                                     |
|                                                              | Secure Flag Fix         | `./secure-to-boolean/secure-to-boolean-migration.ts`                                                                                       |
| [v0.15](https://github.com/novuhq/novu/releases/tag/v0.15.0) | Database TTL            | `./expire-at/expire-at.migration.ts`                                                                                                       |
| [v0.12](https://github.com/novuhq/novu/releases/tag/v0.12.0) | Organization Invite Fix | `./normalize-users-email/normalize-users-email.migration.ts`                                                                               |
| [v0.9](https://github.com/novuhq/novu/releases/tag/v0.9.0)   | Seen/Read Support       | `./seen-read-support/seen-read-support.migration.ts`                                                                                       |
| [v0.8](https://github.com/novuhq/novu/releases/tag/v0.8.0)   | Secure Credentials      | `./fcm-credentials/fcm-credentials-migration.ts`<br />`./encrypt-credentials/encrypt-credentials-migration.ts`                             |
| [v0.4](https://github.com/novuhq/novu/releases/tag/v0.4.0)   | Change Promotion        | `./changes-migration.ts`                                                                                                                   |


# Glossary
Source: https://v0.x-docs.novu.co/additional-resources/glossary

Definitions

## Introduction

In this section, you’ll find a list of key terms, their definitions and various concepts associated with Novu. Familiarising yourself with these will help you understand and use Novu better. They will help you navigate our docs more effectively and utilise Novu to its maximum potential.

If you have any questions or need further clarification on any of the terms listed above, please feel free to reach out to our support team or join our community!

## List of key terms and definitions

## Notification

A brief message or alert that informs users about events, updates, or some other information

## Channels

Novu lets you send notifications across different communication mediums, including emails, in-app messages, push notifications, SMS, and chat. Each of these five communication mediums is referred to as a notification ‘channel’.

<Frame>
  <img />
</Frame>

## Providers

Providers are responsible for handling message delivery across various channels. Novu currently supports multiple notification channels, each with its own set of providers.

* Chat: This channel offers these providers:
  * Discord
  * MS Teams
  * Slack
  * Zulip
* Email: The Email channel features these providers:
  * Sendgrid
  * Amazon SES
  * Sendinblue
  * Resend
  * SparkPost
  * Postmark
  * Mailjet
  * Mailtrap
  * Plunk
  * Braze
  * Mailersend
  * Outlook 365 (based on a custom SMTP server)
  * Mailgun
  * Mandrill
  * Netcore
  * Infobip, and
  * Custom SMTP
* SMS: The SMS channel features these providers:
  * Twilio SMS
  * SMS77
  * Africa’s Talking
  * Infobip
  * Nexmo
  * Plivo
  * Sendchamp
  * AWS SNS
  * Telnyx
  * Termii
  * Firetext
  * Gupshup
  * Clickatell
  * Azure SMS
  * BulkSMS
  * SimpleTexting
  * MessageBird
* Push Notification Providers: This channel includes these providers:
  * Firebase Cloud Messaging (FCM)
  * Expo Push
  * Apple Push Notification Service (APNS)
  * One Signal
  * Pushpad
  * Pusher Beams
  * Push Webhook
* In-app Notification Center: Novu provides you with a set of APIs and components to create rich customized notification center experiences:
  * React component
  * Angular component
  * Vue component
  * Web component
  * iFrame embed
  * Custom styling
  * Headless notification center

## Subscribers

Subscribers are entities designated to receive the notifications you send. Each subscriber in Novu is uniquely identified by their `subscriberId`.

## Actor

An `actor` refers to a user or subscriber who initiates actions that trigger events within the system. Each actor is uniquely identified by an "actorId," also known as "subscriberId," which distinguishes them from others.

Actors hold user-related variables, such as subscriber properties and data payload, containing information like names, emails, and custom data.

Additionally, actors can enhance notifications by allowing their avatars to be displayed, improving the context and identification of notifications.

Including actors in event data enables precise tracking and personalization of actions and events in the Novu platform.

## Workflow

Workflow templates define the flow of messages sent to subscribers.

## Topics

Topics facilitate bulk notifications to multiple subscribers simultaneously, streamlining communication.

## Digest Engine

The digest engine aggregates multiple trigger events into a single message, ensuring efficient communication.

## Delay Actions

Delay actions introduce time intervals between workflow steps, optimizing message delivery timing.

## Step Filter

Step filters customize workflow by specifying notification criteria, enhancing communication efficiency.

## Organizations

Organizations allow separation of notifications across multiple products, managed through the Novu web dashboard.

<Frame>
  <img />
</Frame>

## Environments

Novu runs all your requests in the context of an environment. By default, Novu creates two environments when your account was created, `development` and `production`.

1. `Development environment`: The development environment is used for testing purposes and validating notification changes prior to committing them to the production environment.
2. `Production environment`: It will be your live/production environment, you cannot make changes to this environment directly. You will first have to make the changes in the `development` environment and then promote it to `production`. This is a read-only environment.

## Data associated with an environment

* Subscribers (can’t be promoted to production)
* Workflows (can be promoted to production)
* Messages
* Execution logs
* Connected integrations (can’t be promoted to production)
* Notification feeds (can be promoted to production)
* Brand-related assets and settings

## Team members

Members of a team have access to the Novu web dashboard. This allows you to have individuals work on and manage templates and notifications.

## Layouts

Layouts are HTML designs or structures to wrap the content of email notifications. Layouts can be manipulated and assigned to new or existing workflows within the Novu platform, allowing users to create, manage, and assign these layouts to workflows, so they can be reused to structure the appearance of notifications sent through the platform.


# Idempotent Requests
Source: https://v0.x-docs.novu.co/additional-resources/idempotency

Retry API requests fearlessly, ensuring the operation performs just once!

Our platform has a seamless integration of optional [idempotent](https://en.wikipedia.org/wiki/Idempotence) requests for `POST` and `PATCH` operations.
This integration closely adheres to the [Idempotency-key ietf draft](https://datatracker.ietf.org/doc/draft-ietf-httpapi-idempotency-key-header/).
These idempotent operations deliver the same result regardless of the number of requests made, using an idempotent key.

Leveraging this feature guarantees the safety and reliability of your requests, especially in cases where network or communication issues might inject uncertainty into request outcomes.
Idempotent requests are <b>critical</b> for workflows that require the insurance of only one successful delivery request.

<Note>
  This feature was introduced in version 0.22.0 and is fully operable from 0.24.0 and beyond. Currently, the Idempotency headers are not enabled on the cloud platform but are available for self-hosting.
</Note>

<Warning>
  Please be aware that idempotency might not be supported in all community SDKs.
</Warning>

## How to Perform an Idempotent Request with SDKs

Supporting SDKS will implement Idempotency for you as long as you have retries turned on.
Not only is this seamless but it also ensures that no event request is dropped provided that your system stays up.

<Note>
  Idempotency is only implemented for /events/trigger endpoint.
</Note>

### Idempotent request with api

To make an idempotent request, simply include the `Idempotency-Key: <key>` in your request header.
This key should be a unique client-generated value, boasting enough entropy to prevent collisions;
we recommend a collision-resistant Unique Identifier, such as UUIDv7, CUID, or ULID, as your idempotency keys.

## Understanding Response Replay

Our API stores the status code and response body from your initial idempotent request.
This way if an identical idempotency key appears in a later request,
the API will replay the saved response from the original request - even if it involves client or server error responses.

In the event of a response replay, the response will carry an `Idempotency-Replay: true` header.

## Idempotent Request Responces

Here are some unique pieces constraints you should be aware of especially if you are not using the sdk:

1. A `<key>` exceeding 255 characters will trigger a `400 Bad Request` error.
2. An inconsistent request body compared to the initial request will return a `422 Unprocessable Entity` error.
3. A ongoing processing of the initial request that hasn't yet responded will result in a `409 Conflict` error. This will include a `Retry-After` header.

<Note>
  Results will <b>not</b> saved if an API request is invalid.
</Note>

## Expiring Keys

All idempotency keys are ensured to be automatically removed once they are 24 hours and 1 minute old.
After this period, the reused key will be treated as a new request and response.

## Practical Examples

### Example 1 - No idempotency

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
      to: {
        subscriberId: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      },
      payload: {
        name: "Hello World",
      },
      actor: "actorId",
      tenant: "tenantIdentifier",
    });
    ```
  </Tab>
</Tabs>

### Example 2 - Idempotency Active

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>", {
        retryConfig: {
            retryMax: 5
        }
    });

    // This request is now idempotent
    await novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
      to: {
        subscriberId: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      },
      payload: {
        name: "Hello World",
      },
      actor: "actorId",
      tenant: "tenantIdentifier",
    });
    ```
  </Tab>
</Tabs>

## References

* [https://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/eo](https://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/eo)


# Blog Posts, Articles & Videos
Source: https://v0.x-docs.novu.co/additional-resources/posts-videos-and-articles

Blog posts, articles, and videos

## Blog Posts / Articles

* [🪄✨Building a blog with a liking feature using React, Hanko and Novu 🔥](https://dev.to/novu/building-a-blog-with-a-liking-feature-using-react-hanko-and-novu-1m81)
* [How to add In-App notifications to any web app!](https://dev.to/novu/how-to-add-in-app-notifications-to-any-web-app-1b4n)
* [How To Add In-App Notifications To Your Angular App](https://dev.to/novu/how-to-add-in-app-notifications-to-your-angular-app-2dp3)
* [Creating A Hot New Food Delivery App with Novu](https://dev.to/novu/creating-a-hot-new-food-delivery-app-with-novu-2e75)

## Videos

* [How to add In-App Notifications to your Web app with Novu](https://www.youtube.com/watch?v=KD8zoUb132k)
* [Subscriber (User) Management & Bulk Import Guide](https://www.youtube.com/watch?v=m5nhYEuz86I\&t=92s)
* [Workflow Optimization with Delay Actions](https://www.youtube.com/watch?v=kCMB-WdbzJo)

## External Resources

* [Simplify configuration management with Novu and Configu](https://configu.com/blog/video-first-steps-with-configu/)
* [Vercel and Novu integration](https://vercel.com/integrations/novu)
* [Novu is building open-source notification infrastructure for developers](https://venturebeat.com/business/novu-is-building-open-source-notification-infrastructure-for-developers/)
* [Novu - An open-source notification infrastructure for developers](https://reactjsexample.com/-f0-9f-9a-80-open-source-notification-infrastructure-for-products/)
* [Novu Tackles Notification Infrastructure Management](https://thenewstack.io/novu-tackles-notification-infrastructure-management/)
* [Novu: Omni-channel notification infrastructure for developers](https://www.decibel.vc/articles/novu-omni-channel-notification-infrastructure-for-developers)


# Discord
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/discord

Learn about how to use Discord provider for chat notifications

When using Discord, you will have to store the integration credentials within the subscriber entity. Discord supports two ways to do this:

1. Using the **Discord Webhook** integration.
2. Using the **Discord Bot** integration.

Right now, Novu only supports the **Discord Webhook** integration. This approach has been because the easiest way to set it up is when you have a predefined destination for where the notifications should be sent. It's particularly useful for notifying a specific channel about updates.

**Quickstart:**

To get started with using Novu’s Discord Webhook integration, you need a ‘webhook token’. Here’s how you can generate the same for testing purposes:

1. Go to the channel you want to add the webhook to (you need to be an admin of the discord server).
2. Right-click the channel and select "Edit Channel".
3. Integrations -> Webhooks -> New Webhook
4. Copy the webhook URL.
5. After obtaining the webhook URL in the previous step, you need to store it within the subscriber entity. Doing this ensures that Novu knows where (in which discord channel) to send the notification to. Here’s how to do it:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Discord, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "discord",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "discord-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum to specify the provider.
* The third parameter is the credentials object. In this case, we use the `webhookUrl` property to specify the webhook URL generated in the previous step.

6. You are all set up and ready to send your first chat message via our `@novu/node` package or directly using the REST API in the channel you chose on your discord server.


# MS Teams
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/ms-teams

Learn about how to use MS Teams provider for chat notifications

MS Teams does not need any `API Key` or `Client ID` to send notifications. Our current implementation is based on the [Incoming Webhook URL](https://learn.microsoft.com/en-us/microsoftteams/platform/webhooks-and-connectors/how-to/add-incoming-webhook?tabs=newteams%2Cjavascript). It is a URL that you can use to send messages to a specific channel. This URL needs to be stored on the subscriber entity

Similar to [Discord](https://www.notion.so/Additional-Resources-65ef4aca5d0f4115947030c2f5705101?pvs=21), the credential for this provider needs to be stored in the [subscriber entity](/api-reference/subscribers/update-subscriber-credentials).

## Creating incoming webhook URL

Checkout step by step instructions on microsoft team's documentation on how to [create an incoming webhook url](https://docs.microsoft.com/en-us/microsoftteams/platform/webhooks-and-connectors/how-to/add-incoming-webhook?tabs=newteams%2Cjavascript).

<Frame>
  <img />
</Frame>

## Storing webhook url on subscriber entity

The URL generated above will be the target channel of a subscriber that you want to integrate with. To make this connection, you have to:

1. Copy the URL that you generated above
2. Update the subscriber credentials with this URL using the MS Teams provider id. You can do this step by using the `@novu/node` library, as shown below:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials(
      'subscriberId', 
      ChatProviderIdEnum.MsTeams, // providerId
      { webhookUrl: "<WEBHOOK_URL>" },
      'msteams-MnGLxp8uy' // integration identifier
    );
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "msteams",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "msteams-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum to specify the provider.
* The third parameter is the credentials object, in this case, we use the `webhookUrl` property to specify the MS Teams channel webhook URL or by calling the `Update Subscriber Credentials` endpoint on Novu API. Check endpoint details [here](https://docs.novu.co/api/update-subscriber-credentials/).

<Info>
  If you are looking to use  provider in different way or your usecase is not covered by this documentation, you can always reach out to our team at [support@novu.co](mailto:support@novu.co) or via [Discord](https://discord.novu.co)
</Info>


# Chat Channel Overview
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/overview

Learn the process of configuring and using chat providers with Novu

Novu can be used to deliver chat messages to your customers using a unified delivery API. You can easily integrate your favorite chat provider using the built-in integration store.

<iframe />

## Configuring chat providers

To configure a chat provider, you need to add a new integration to your Novu account. You can do this by navigating to the integration store and clicking on the **Add a provider** button and then select the chat provider you want to configure. You can find the [integration store](https://web.novu.co/integrations?utm_campaign=docs-chat-overview) in the left sidebar of the Novu dashboard.

Each chat provider requires defferent type of credentials. There are few providers which does not require any credentials example: `Discord`

## Sending chat message

Steps to send a chat message using Novu:-

1. Add a chat provider integration to your Novu account from the integration store. Enter credentials if required and save the integration. Follow corresponding provider documentation to get the required credentials.
2. Create a new subscriber

> Step 2 can be skipped if you already have a subscriber. You can use the `subscriberId` of an existing subscriber.

3. [Update](/channels-and-providers/chat/overview#update-credential-webhookurl) the subscriber credential `webhookUrl` for this provider and integration.

4. Create a new [worklow](/workflows/notification-workflows) or use an existing workflow. Add chat channel and [write content](/content-creation-design/notification-content-creation#chat) for the message.

5. Trigger this workflow to above `subscriberId` using trigger identifier

6. Check the chat provider if message is received. If not, check the logs in [activity feed](/activity-feed/introduction) for for any errors.

## Update credential webhookUrl

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Slack, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "slack",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "slack-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

<Info> Integration identifier is similar to Provider identifier but it is different than Provider Id. It is unique for each integration. You can find the `integrationIdentifier` in the integration store page.  </Info>

## Common errors

Common erros and reason of those errors while sending chat messages using Novu.

1. Subscriber does not have a configured channel.
   * if the subscriber does not have credentials set up for any of the chat provider.
2. Webhook URL for the chat channel is missing.
   * `webhookUrl` field is null, undefined or not set. Check using [get subscriber api](/api-reference/subscribers/get-subscriber).
3. Subscriber does not have an active integration.
   * if subscriber have credentials set but integration is either not active or deleted for this credential.

<Tip>
  <MissingProvider />
</Tip>


# Slack
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/slack

Learn about how to use Slack provider for chat notifications

When using Slack you will have to save the integration credentials in the subscriber entity.

This guide will walk you through the steps needed to obtain the `webhookUrl` that Novu requires to send chat messages to your customers.

We will provide the basic flow that the user needs to perform, to successfully send notifications via the Slack integration.

<Note>We've a [dedicated guide](/guides/slack-guide) on integrating Novu in a Slack app.</Note>

### Creating application

This step is optional, if you already have a Slack application you can reuse it.

1. Go to Slack's developer dashboard [https://api.slack.com/apps](https://api.slack.com/apps).
2. Create a new application.

### Integrating Novu with Slack

There are two ways to integrate Novu with Slack - Novu Managed (recommended) and manually managed. Let’s look at both of them in detail:

### 1. Novu Managed (Recommended)

If you use this approach, then Novu will manage the OAuth flow and store the credentials

1. Configure your Slack application as mentioned [below](#configuring-slack-application).
2. You need to make a network request to the `Shareable URL` to perform authentication.
3. You can find the `Shareable URL` in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integrations-slack)

<Frame>
  <img />
</Frame>

4. You can either add the `Add to Slack` button or use the `Shareable URL` directly, in the application you'll be using Novu in.
   <Info>The network request to the 'Shareable URL' will happen when the user clicks the 'Add to Slack' button.</Info>
5. This is to request permission for access (scope: incoming-webhook).
6. You can use the generated `Shareable URL` that is found under the Slack integration in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integrations-slack). The `Shareable URL` should have the following format:

```bash theme={null}
https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials/slack/oauth?environmentId=<ENVIRONMENT_ID>&integrationIdentifier=<PROVIDER_ID>.

```

* `SUBSCRIBER_ID` is a custom identifier used when identifying your users within the Novu platform.
* `ENVIRONMENT_ID` is a context of an environment you can locate your environment id in the setting in the [dashboard settings](https://web.novu.co/settings?utm_campaign=docs-integrations-slack).
* `PROVIDER_ID` (optional) is a unique identifier of the integration and is required when you have multiple slack integrations in Novu. You can locate your integration identifier in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integratons-slack). When not provided, the last created integration will be used.
  If you are using the `Add to Slack` button you have to provide the `Shareable URL` as the `redirect_uri` parameter like in this example. Make sure that the `Shareable URL` is URL encoded:

```html theme={null}
<a
  href="https://slack.com/oauth/v2/authorize?client_id=CLIENT_ID&scope=incoming-webhook&user_scope=&redirect_uri=https%3A%2F%2Fapi.novu.co%2Fv1%2Fsubscribers%2FSUBSCRIBER_ID%2Fcredentials%2Fslack%2Foauth%3FenvironmentId%3DENVIRONMENT_ID%26integrationIdentifier%3DINTEGRATION_IDENTIFIER"
  ><img
    alt="Add to Slack"
    height="40"
    width="139"
    src="https://platform.slack-edge.com/img/add_to_slack.png"
    srcset="
      https://platform.slack-edge.com/img/add_to_slack.png    1x,
      https://platform.slack-edge.com/img/add_to_slack@2x.png 2x
    "
/></a>
```

7. Either you use the 'add to Slack' button or use the `Shareable URL`, you should land here:

<Frame>
  <img />
</Frame>

8. Then you'll be redirected to the address you chose in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integrations-slack):

<Frame>
  <img />
</Frame>

<Info>You can use the URL of whichever page you want your users to land on, after successful execution</Info>
9\. That's it! Now you can trigger your workflow and send notifications:

<Frame>
  <img />
</Frame>

<Note>Don't forget to check out our [dedicated guide](/guides/slack-guide) on integrating Novu in a Slack app for more.</Note>

### 2. Manually managed

To use the manually managed option, you need to generate a `webhookUrl` and plug it into your backend.

1. Goto 'Incoming Webhooks' in your Slack app settings and turn it on.

<Frame>
  <img />
</Frame>

2. Click on the 'Add New Webhook to Workspace':

<Frame>
  <img />
</Frame>

3. Now, go ahead and select the channel in which you want to send notifications and click 'allow'.

<Frame>
  <img />
</Frame>

4. Then, copy the 'webhookUrl' from Slack.

<Frame>
  <img />
</Frame>

5. Now, you need to save the `webhookUrl` on the relevant subscriber entity in Novu. Here's an example to do the same using our Node SDK:

## Update credential webhookUrl

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Slack, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "slack",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "slack-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum.Slack if you’re using Node, else string of Slack to specify the provider.
* The third parameter is the credentials object. In this case, we use the `webhookUrl` property to specify the webhook URL generated in the previous step.

6. You are all set up and ready to send your first chat message via our @novu/node package or directly using the REST API.

## Configuring Slack application

1. Go to OAuth & Permissions on Slack's Developer Dashboard and add your REDIRECT\_URL in Redirect URLs.
   * If you use a manual Management solution, add the API endpoint you created in Step 1.
   * If you use the Novu Managed solution add `https://api.novu.co/v1/subscribers`.
2. Go to Incoming Webhooks from the left menu and Activate Incoming Webhooks.
3. Go to Manage Distribution and at the bottom of the page, tick Remove Hard Coded Information and Activate Public Distribution.

### Enabling HMAC Encryption

To enable Hash-Based Message Authentication Codes, you need to do the following steps:

1. Visit the integration store page and enable HMAC encryption under your chat provider.

2. The next step would be to generate an HMAC encrypted subscriberId on your backend:

   ```jsx theme={null}
   import { createHmac } from 'crypto';

   const hmacHash = createHmac('sha256', process.env.NOVU_API_KEY)
     .update(subscriberId)
     .digest('hex');

   ```

3. Add the newly created hash HMAC to the Sharable URL as a query.

This concludes the Slack provider guide.


# How to send WhatsApp Business notifications with Novu
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/whats-app

Learn about how to use WhatsApp for chat notifications

## Getting Started

To integrate WhatsApp Business with Novu, You will have to create a facebook developer app and obtain the necessary credentials.

### Step 1: Create a Facebook Developer App

Visit the [Facebook Developer Portal](https://developers.facebook.com/apps/) and create a new app.

Select "Other" for "What do you want your app to do?" and select "Business" for "Select an app type".

### Step 2: Setup WhatsApp Product

On the App Setup page, click on "Set Up" under the "WhatsApp" product. You will need to create or add a Facebook Business Account to your app.

### Step 3: Send a Sandbox Message

Copy the following pieces and paste them in the Novu WhatsApp Business integration settings:

* Temporary Access Token - Access API token Field
* Phone Number ID - Phone Number Identification Field

<Warning>
  It's important to note that the test credentials for whatsapp cannot be used in production and will expire in 24 hours.
  You will need to submit your app for review to obtain production credentials.
</Warning>

### Step 4: Add a Test Phone Number

You can add a test phone number to the sandbox by clicking on the "Add Phone Number" button.
This number can be used to test your integration with Novu before submitting for a review.

### Step 5: Send a test notification from Novu

You can now create a new Workflow with a "Chat" node, and add your content. Save your workflow, and click on "Trigger Notification" Button.

In the to field, specify the phone number you added in the sandbox, and click on "Send Notification".

```json theme={null}
{
  "subscriberId": "TEST_SUBSCRIBER_ID",
  "phone": "+11111111111"
}
```

and in the `overrides` field, add the following:

```json theme={null}
{
  "chat": {
    "template": {
      "name": "hello_world",
      "language": {
        "code": "en_US"
      }
    }
  }
}
```

<Info>
  For test credentials you can only used the built in Whats App Template.
</Info>

## Going to Production

### Register a Business Phone Number

To go live you will need to add a real business phone number and submit your app for review.
Follow the [Facebook Instructions](https://developers.facebook.com/docs/whatsapp/cloud-api/get-started/add-a-phone-number) on how to proceed.

### Generate a permanent access token

Follow the [Facebook Instructions](https://developers.facebook.com/docs/whatsapp/business-management-api/get-started/) on how to generate a permanent access token.
Depending on your use case.

### Create a WhatsApp Template

You will need to create a WhatsApp Template to send notifications to your customers. Create a template in the [Business Manager](https://business.facebook.com/wa/manage/message-templates) and submit it for review.
After your template is approved, you can use the `template_name` to send notifications to your customers.

To send a notification with a template, you will need to add the following to the `overrides` field:

```typescript theme={null}
novu.trigger('workflow-id', {
    to: {
        subscriberId: "SUBSCRIBER_ID",
        phone: "+11111111111"
    },
    payload: {},
    overrides: {
        chat: {
            template: {
                name: "template_name",
                language: {
                    code: "en_US"
                }
            }
        }
    }
})
```


# Zulip
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/zulip

Learn about how to use Zulip provider for chat notifications

Zulip does not need any API Key or client ID to push messages in it. All it needs is the webhook URL of the channel you want to send messages to. That itself acts as the credential.

Similar to Discord, the credential for this provider needs to be stored in the subscriber entity.

## Getting a Zulip webhook URL

* Sign up or Login to your Zulip account.

* Click on the Settings icon in the top right corner of the screen, and then click "Personal settings" from the drop-down menu.

<Frame>
  <img />
</Frame>

* Click "Add a new bot" button in "Bots" tab.

<Frame>
  <img />
</Frame>

* Set bot type as "Incoming webhook".

<Frame>
  <img />
</Frame>

* Click the small link icon to generate webhook URL for provider. Set Integration as `Slack compatible webhook`, choose your channel and copy webhook URL.

<Frame>
  <img />
</Frame>

## Connecting our subscribers to Zulip

The URL generated above will be the target channel of a subscriber that you want to integrate with. To make this connection, you have to:

1. Copy the URL that you generated above

2. Update the subscriber credentials with this URL using the Zulip provider id. You can do this step by using the `@novu/node` library, as shown below:

## Update credential webhookUrl

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Zulip, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "zulip",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "zulip-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum to specify the provider.
* The third parameter is the credentials object, in this case, we use the `webhookUrl` property to specify the MS Teams channel webhook URL or by calling the `Update Subscriber Credentials` endpoint on Novu API. Check endpoint details [here](https://docs.novu.co/api/update-subscriber-credentials/).

3. You are all set up and ready to send your first chat message via our `@novu/node` package or directly using the REST API.


# Novu Providers
Source: https://v0.x-docs.novu.co/channels-and-providers/default-providers

Learn about the default Novu email and sms providers

## Novu Providers

To help you evaluate our services better, Novu provides an email and sms provider by default for every account. After signing up, you can go to the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-default-providers) on the Novu web dashboard to see this.

<Note>
  This feature is available only in Novu cloud. This feature will not work in community self
  hosted version and local environment.
</Note>

## Novu Email Provider

If you've a newly signed-up account on Novu, it will look like this:

<Frame>
  <img />
</Frame>

## Novu SMS Provider

And this is what the default Novu SMS provider looks like:

<Frame>
  <img />
</Frame>

<Info>
  The default email and sms providers are for evaluation purposes only and their use in production-grade apps is not recommended. You should switch to any of our [numerous other providers](/additional-resources/glossary#3-providers) for production apps. Also, there are two modes for default Novu providers - Development and Production.
</Info>

## Novu In-app Provider

In addition to email and sms, we also have in-app provider:

<Frame>
  <img />
</Frame>

It is the only provider for the in-app channel and it *can be used in production apps*. Unlike sms and email, it is not active by default and needs to be turned on separately. It can be scaled as per your need and it is a 'pay as you go' offering. You can check [this](https://novu.co/pricing/?utm_campaign=docs-default-providers) for more details.

## Limits of the Novu Providers

Following are the limits for our email and sms providers:

1. Email: 300 emails per organization per month
2. SMS: 20 messages per organization per month

To send more than these limits, you can configure a different provider for a specific channel. Read more about them [here](/channels-and-providers/integration-store).


# Amazon SES
Source: https://v0.x-docs.novu.co/channels-and-providers/email/amazon-ses

Learn how to use the Amazon SES provider to send email notifications using Novu

You can use the [Amazon SES](https://aws.amazon.com/ses/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Amazon SES provider in the email channel, you will need to create an SES account and add your credentials to the Amazon SES integration on the Novu platform.

## Setting up SES in AWS?

* Either use a root AWS account or create a new IAM account with appropriate permission policies.
  <Tip>Example policy rule `arn:aws:ses:<REGION>:<ACCOUNT>:identity/*`</Tip>
* Create a new access key and save generated `ACCESS_KEY_ID` and `ACCESS_SECRET_KEY` carefully
* Choose Amazon Simple Email Service.
* Create a new identity.
* Either choose domain or email.
* Verify your domain (by adding a few DNS records as mentioned in SES instructions) or email (AWS sends a verification email to your email).
* Verify the recipient email also by creating a new email identity type \[only in sandbox mode].
* Test if your SES is set up correctly using the test email feature.

## Creating an SES integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-integrations-ses) page on Novu.
* Click on Add a Provider.
* Select Amazon SES service.
* Enter previously saved `ACCESS_KEY_ID` and `ACCESS_SECRET_KEY`.
* Fill in the `From email address` field using the authenticated sender email id in the previous step.
* Enter `region` and `Sender name` also.

<Tip>Example region format:- `us-east-1`. By default Novu uses `us-east-1` region.</Tip>

* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Amazon SES in Novu.

## FAQs

<AccordionGroup>
  <Accordion title="Trigger from novu is successful but the subscriber is not receiving email.">
    Possible reasons:

    1. You have not verified the subscriber's email address in SES (if you are in a sandbox environment).
    2. Your daily sending limit has been reached (if you are in a sandbox environment).
    3. You have entered the wrong aws region in the integration form.
  </Accordion>
</AccordionGroup>


# Braze
Source: https://v0.x-docs.novu.co/channels-and-providers/email/braze

Learn how to use the Braze provider to send email notifications using Novu

You can use the [Braze](https://braze.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Braze provider in the email channel, you will need to create a [Braze account](https://braze.com/) and add your API key and other credentials to the Braze integration on the Novu platform.

# Generating an API Key

To generate a new API key in Braze, you can follow these steps:

* [Sign up](https://braze.com) or [Log in](https://braze.com) to your Braze account.
* Go to **Settings > API Keys**.
* Click **+ Create New API Key**.
* Give your new key a name for identification at a glance.
* Select the right permission you want to be associated with the new API key.

# Creating a Braze integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-braze) page on Novu.
* Click on `Add a Provider`.
* Locate **Braze** under the Email section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `API Key`.
* Enter the `Base URL`.
* Enter the `From email address`.
* Enter the `Sender name`.
* Click on the **Update** button.


# Custom SMTP
Source: https://v0.x-docs.novu.co/channels-and-providers/email/custom-smtp

Learn how to use the Custom SMTP provider to send email notifications using Novu

You can use a Custom SMTP provider like [Nodemailer](https://nodemailer.com/about/) to send transactional emails through your custom SMTP server to your customers using the Novu Platform with a single API.

# Getting Started

To use the Custom SMTP provider in the email channel, you will need to have your personal SMTP server configured and add `host`, `port`, `user`, and `password` to the Custom SMTP integration on the Novu platform.

You can also provide value **`true`** for the `secure` field if you want the connection to be secure, and if not, leave it empty.

### DKIM (DomainKeys Identified Mail)

DKIM options can be used in order to sign messages sent using Custom SMTP with DKIM keys.

Those options are:

* `DKIM Domain`
* `DKIM Private Key`
* `DKIM Key Selector`

# Creating a Custom SMTP integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-customsmtp) page on Novu.
* Click on Add a Provider.
* Select Custom SMTP service.
* Enter your SMTP credentials
  * `host`
  * `port`
  * `username`
  * `password`
  * `secure` (on demand)
  * And `DKIM` options if you want to sign messages with *DKIM*
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Custom SMTP in Novu.


# Infobip - email
Source: https://v0.x-docs.novu.co/channels-and-providers/email/infobip

Learn how to use the Infobip provider to send email notifications using Novu

You can use the [Infobip](https://www.infobip.com/developers/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Infobip provider in the email channel, you will need to create an Infobip account and add your API key and Base URL to the Infobip integration on the Novu platform.

# Generating an API Key

To generate a new API key in Infobip, you can follow these steps:

* [Sign up](https://www.infobip.com/signup) or [Log in](https://portal.infobip.com/login/) to your Infobip account.
* Navigate to the [Settings](https://portal.infobip.com/settings/accounts/api-keys) of your account and look for the API Keys section at the top of the settings page.

# Creating an Infobip integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-infobip) page on Novu.
* Click on Add a Provider.
* Select Infobip service.
* Enter your Infobip API Key.
* Enter your Base URL.
  * To see your base URL, log in to the account. Once logged in, on all pages, you should see your base URL in this format: `xxxxx.api.infobip.com`.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Infobip in Novu.


# Mailersend
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailersend

Learn how to use the MailerSend provider to send email notifications using Novu

[MailerSend](https://www.mailersend.com/) is an email delivery service that allows you to send emails from your application.

## Getting Started

To use the MailerSend provider in the email channel, you will need to create a MailerSend account and add your API key to the MailerSend integration on the Novu platform. To generate the API token go visit the [MailerSend API Tokens](https://www.mailersend.com/help/managing-api-tokens) page.

## Creating the MailerSend integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mailersend) page on Novu.
* Click on Add a Provider.
* Select MailerSend service.
* Enter the API key.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using MailerSend in Novu.

## Using MailerSend template

Novu has its own email editor for writing email template. If you want to use pre made template from MailerSend, you can use `customData` filed of email overrides to send template details. Make sure your `Api Key` has enough permission to read and process the template.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import {
      Novu
    } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.trigger("workflowIdentifier", {
      to: "subscriberId",
      payload: {},
      overrides: {
        email: {
          customData: {
            // mailersend template templateId
            templateId: 'mailersend-template-id',
            // mailersend template variables
            personalization: [{
              email: 'recipient@email.com',
              data: {
                items: {
                  price: '',
                  product: '',
                  quantity: '',
                },
                order: {
                  date: '',
                  order_number: '',
                  billing_address: '',
                  customer_message: '',
                },
                store: {
                  name: '',
                },
                invoice: {
                  total: '',
                  subtotal: '',
                  pay_method: '',
                },
                customer: {
                  name: '',
                  email: '',
                  phone: '',
                },
              },
            }, ],
          },
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl --location 'https://api.novu.co/v1/events/trigger' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <NOVU_API_KEY>' \
    --data '{
        "name": "workflowIdentifier",
        "to":  ["subscriberId"],
        "payload": {},
        "overrides": {
            "email": {
                "customData": {
                    "templateId": "mailersend-template-id",
                    "personalization": [{
                        "email": "recipient@email.com",
                        "data": {
                            "items": {
                                "price": "",
                                "product": "",
                                "quantity": ""
                            },
                            "order": {
                                "date": "",
                                "order_number": "",
                                "billing_address": "",
                                "customer_message": ""
                            },
                            "store": {
                                "name": ""
                            },
                            "invoice": {
                                "total": "",
                                "subtotal": "",
                                "pay_method": ""
                            },
                            "customer": {
                                "name": "",
                                "email": "",
                                "phone": ""
                            }
                        }
                    }]
                }
            }
        }
    }'
    ```
  </Tab>
</Tabs>


# Mailgun
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailgun

Learn how to use the Mailgun provider to send email notifications using Novu

You can use the [Mailgun](https://mailgun.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Mailgun provider in the email channel, you will need to create a Mailgun account and add your API key and domain name to the Mailgun integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mailgun, you can follow these steps:

* [Sign up](https://signup.mailgun.com/new/signup) or [Log in](https://login.mailgun.com/login/) to your Mailgun account.
* Click on the **Profile** section in the top right corner of the screen, and then click "API Keys" from the drop-down menu.
* On the [API Keys](https://app.mailgun.com/app/account/security/api_keys) page, copy the generated **Private API Key**

# Adding a new domain name

Mailgun recommends that you add a subdomain as a domain name. To do so:

* Visit the page to add a [domain name](https://app.mailgun.com/app/sending/domains/new).
  * During this process, you will need to choose a region for the domain name which is between `US` and `EU`. The default is `US`.
* Follow the [instructions](https://documentation.mailgun.com/en/latest/user_manual.html#verifying-your-domain-1) to verify the domain name.

# Creating a Mailgun integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mailgun) page on Novu.
* Click on Add a Provider.
* Select Mailgun service.
* Enter your Mailgun API Key.
* Enter your Base URL.
  * For domains created in the EU region, the base URL is: `https://api.eu.mailgun.net/`
  * Otherwise, leave the base URL blank.
* Fill in the `Username`.
* Fill in the `Domain name` registered on Mailgun.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Mailgun in Novu.


# Mailjet
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailjet

Learn how to use the Mailjet provider to send email notifications using Novu

You can use the [Mailjet](https://mailjet.com/) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the Mailjet provider in the email channel, you will need to create a Mailjet account and add your API key to the Mailjet integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mailjet, you can follow these steps:

* Log in to your Mailjet account.
* Click on **Settings** in the top-right corner of the screen, and then click **API KEYS & TRACKING** from the drop-down menu.
* On the API Keys page, click the **Create an API Key** button.
* Give the API key a name and choose the access level **Write and Read**
* Click the **Generate Key** button to create the new key. Once generated you can see the key but it will be hidden after the refresh

# Authenticating your sender identity

Before you can send emails on a large scale, you will need to authenticate your Sender identity. This is due to the latest regulatory changes regarding SPAM rules and email fraud. Most of the providers including Mailjet require you to authenticate your Sender identity before you can send emails.

Mailjet allows you to authenticate your sender identity using one of the following methods:

* [Single Sender Verification](https://dev.mailjet.com/email/guides/senders-and-domains/#sender-validation) - This is the easiest way to authenticate your sender identity.
* [Entire Domain Authentication](https://dev.mailjet.com/email/guides/senders-and-domains/#spf-and-dkim-validation) - This is recommended if you are sending emails from multiple accounts under your domain.

# Creating a Mailjet integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mailjet) page on Novu.
* Click on Add a Provider.
* Select Mailjet service.
* Enter your Mailjet API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Mailjet in Novu.


# Mailtrap
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailtrap

Learn how to use the Mailtrap provider to send email notifications using Novu

You can use the [Mailtrap](https://mailtrap.io/email-sending/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Mailtrap provider in the email channel, you will need to create a Mailtrap account and add your API key to the Mailtrap integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mailtrap, you can follow these steps:

* [Sign Up](https://mailtrap.io/register/signup) or [Log in](https://mailtrap.io/signin) to your Mailtrap account.
* Click on the **Email Sending** link on the sidebar, and then click the "Sending Domains" link that pops up from the available options.
* On the [Sending Domains](https://mailtrap.io/sending/domains) page, type your domain name and confirm with the `Add Your Domain` button. Then, proceed to copy DNS records Mailtrap provides to your domain’s DNS.
* Go to [API Keys](https://mailtrap.io/api-tokens) page and copy token with `Domain Admin` access level for your registered domain.

# Authenticating your Sender Identity

Before you can send emails, you will need to [verify your sending domain ownership](https://help.mailtrap.io/article/69-sending-domain-setup). Mailtrap rejects sending emails from unverified domains to prevent spam and email fraud.

# Creating a Mailtrap integration with Novu

* Visit the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-mailtrap) on the Novu web dashboard.
* Click on Add a Provider.
* Select Mailtrap service.
* Enter your Mailtrap API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications through Mailtrap using Novu.


# Mandrill
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mandrill

Learn how to use the Mandrill provider to send email notifications using Novu

You can use the [Mandrill by Mailchimp](https://mandrillapp.com/) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the Mandrill provider in the email channel, you will need to create a Mandrill account and add your API key to the Mandrill integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mandrill, you can follow these steps:

* [Sign up](https://login.mailchimp.com/signup/) or [Log in](https://login.mailchimp.com/) to your Mandrill account.
* Navigate to the [Settings](https://mandrillapp.com/settings) of your account and look for the API Keys section at the bottom of the settings page.
* Click on the **+ Add API Key** button to create an API key. Copy the generated key immediately and store it in a secure location. You won’t be able to see or copy the key once you finish generating it.

# Adding a sending domain

To get started, you’ll need to add the domain that you want to send messages from.

* Navigate to the [Settings page](https://mandrillapp.com/settings/sending-domains) and choose Domains
* Type a new domain in the domain input and click Add
* Follow the instructions to [verify ownership](https://mailchimp.com/developer/transactional/docs/authentication-delivery/#authentication) of your sending domain and [update your DNS records](https://mailchimp.com/developer/transactional/docs/authentication-delivery/#configure-your-dns).

# Creating the Mandrill integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mandrill) page on Novu.
* Click on Add a Provider.
* Select Mandrill service.
* Enter your Mandrill API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Mandrill in Novu.


# Netcore
Source: https://v0.x-docs.novu.co/channels-and-providers/email/netcore

Learn how to use the Netcore provider to send email notifications using Novu

You can use the [Netcore](https://netcorecloud.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Netcore provider in the email channel, you will need to create a Netcore account and add your API key to the Netcore integration on the Novu platform.

# Generating an API Key

To generate a new API key in Netcore, you can follow these steps:

* [Log in](https://email.netcorecloud.com/) to your Netcore account.
* Go to the **Integration** page under the **Settings** menu and click on the **API** tab.
* The API Key is hidden for security purposes. Click Show. The system will prompt you to enter your account password. Once you enter the password, the API key will be accessible.

# Setting up sending domains

To start sending emails, you need to add and verify your sending domains. You can either use your top-level domain (e.g. my-company.com) or a sub-domain like email.my-company.com. The verification is done to ensure your sending domain’s security.

Follow the instructions on this [page](https://emaildocs.netcorecloud.com/docs/what-is-a-sending-domain-how-to-set-up-sending-domains) to get started

# Creating a Netcore integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-netcore) page on Novu.
* Click on Add a Provider.
* Select Netcore service.
* Enter your Netcore API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Netcore in Novu.


# Outlook 365
Source: https://v0.x-docs.novu.co/channels-and-providers/email/outlook365

Learn how to use the Outlook 365 provider to send email notifications using Novu

You can use the [Outlook 365](https://office.com/) provider to send transactional emails through your instance of Office 365 to your customers using the Novu Platform with a single API.

## Getting Started

To use the Outlook 365 provider in the email channel, you will need to have the sender's email (user) and the password for the account. This account cannot be a shared mailbox or distribution list. It will need to be properly licensed to send email via Office 365.

## Creating the Outlook 365 integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-office365) page on Novu.
* Click on Add a Provider.
* Select Outlook service.
* Enter your SMTP credentials
  * `from`: The Complete email address of the sending user. (e.g. [jdoe@mycompany.com](mailto:jdoe@mycompany.com))
  * `senderName`: Sender Name should be the same email address of the sending user. (e.g. [jdoe@mycompany.com](mailto:jdoe@mycompany.com))
  * `password`: Password used to sign in with the email account.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Outlook 365 in Novu.

<Note> In order to create outlook integration, turn off multi factor authentication from account security settings.</Note>


# Email providers
Source: https://v0.x-docs.novu.co/channels-and-providers/email/overview

Learn the process of configuring email providers with Novu

Novu can be used to deliver email messages to your customers using a unified delivery API. You can easily integrate your favorite email provider using the built-in integration store.

<iframe />

## Configuring email providers

When creating an email provider integration you will be asked to provide additional fields alongside the provider-specific credentials:

* **Sender name** - Will be displayed as the sender of the message
* **From email address** - Emails sent using Novu will be sent using this address

For some email providers including SendGrid you will have to authenticate the **From email address** to make sure you will send email messages using an authorized address.

## Sending Email Overrides

The overrides field supports an email property. The email overrides field have properties like `to`, `from`, `senderName` etc

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        email: {
          to: ['to@novu.co'],
          from: 'from@novu.co',
          senderName: 'Novu Team',
          text: 'text version of email using overrides',
          replyTo: 'no-reply@novu.co',
          cc: ['1@novu.co'],
          bcc: ['2@novu.co'],
        },
      },
    });
    ```
  </Tab>
</Tabs>

<Note>It's very important to know that Novu merges the `to` field in the email overrides with the subscriber email. It DOES NOT REPLACE IT.</Note>

### Overriding the selected layout

Layout can be selected in the email step editor. To use another layout with emails, selected layout can be overridden using layoutIdentifier in the overrides field.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        layoutIdentifier: 'layout-identifier-value',
      },
    });
    ```
  </Tab>
</Tabs>

## Sending Email attachments

You can easily send attachments with the Novu API by passing the attachments array when triggering an Email based workflow. Attachment file can either be in the `buffer` or `base64` format.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      payload: {
        attachments: [
          {
            file: fs.readFileSync(__dirname + '/data/novu.jpeg'),
            name: 'novu.jpeg',
            mime: 'image/jpeg',
          },
        ],
      },
    });
    ```
  </Tab>
</Tabs>

## Using different email integration

In Novu integration store, multiple email channel type provider integrations can be active at the same time. But only one  provider integration can be primary at a time. This primary integration will be used as a provider to deliver the email by default. If you want to use a different active provider integration then you can use the `integrationIdentifier` email overrides field.

If there are 4 active email integrations with these identifiers:-

1. sendgrid-abcdef
2. sendgrid-ghijkl
3. brevo-abcdef
4. mailersend-abcdef

Here, if `sendgrid-abcdef` is primary integration and you want to use `brevo-abcdef` with this trigger then you can use `integrationIdentifier` email overrides field as below:-

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        email: {
          integrationIdentifier: "brevo-abcdef"
        },
      },
    });
    ```
  </Tab>
</Tabs>

<Info> Integration identifier is similar to Provider identifier but it is different than Provider Id. It is unique for each integration.You can find the `integrationIdentifier` in the integration store page.  </Info>

<Tip>
  <MissingProvider />
</Tip>


# Plunk
Source: https://v0.x-docs.novu.co/channels-and-providers/email/plunk

Learn how to use the Plunk provider to send email notifications using Novu

You can use the [Plunk](https://useplunk.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Plunk provider in the email channel, you will need to create a Plunk account and add your API key to the Plunk integration on the Novu platform.

## Get API Key

To generate a new API key in Plunk, you can follow these steps:

* Log in to your Plunk account.
* Click on `Project Settings` on the side bar and then `API keys` on the tab.
* On the API Keys page, click on `Secret API key` to copy.

## Authenticate your sender identity

Before you can send emails on a large scale, you will need to authenticate your Sender Identity. Plunk allows you to authenticate your sender identity using [Domain Authentication](https://app.useplunk.com/settings/identity)

## Create a Plunk integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-plunk) page on Novu.
* Click on Add a Provider.
* Select Plunk service.
* Enter your Plunk secret API Key.
* Fill the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Plunk in Novu.


# Postmark
Source: https://v0.x-docs.novu.co/channels-and-providers/email/postmark

Learn how to use the Postmark provider to send email notifications using Novu

It is possible to use [Postmark](https://postmarkapp.com/) as a provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

The first step to use the Postmark provider in the email channel is to create a Postmark account and add the personal API key to the Postmark integration on the Novu platform.

# Getting the API Key

* To find the Postmark API key, log into the personal Postmark account and navigate to the servers page.
* After selecting the server to use, the API key (referred to as "Server API tokens") will be in the "API Tokens" section of the server chosen.

# Authenticating the sender's identity

Due to the latest regulatory changes regarding SPAM rules and email fraud, it is needed to authenticate the sender's identity before sending emails on a large scale. Most of the providers, including Postmark, require authentication to unlock the possibility of sending emails.

Postmark allows the authentication of the sender's identity using one of the following methods:

* [Single Sender Verification](https://account.postmarkapp.com/signatures/new) - This is the easiest way to authenticate the sender's identity.
* [Entire Domain Authentication](https://postmarkapp.com/support/article/1046-how-do-i-verify-a-domain#:~:text=be%20verified%20automatically.-,Navigate%20to%20Sender%20Signatures.,to%20your%20DNS%2C%20choose%20Verify.) - This is recommended for sending emails from multiple accounts under the same domain.

# Create a Postmark integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-postmark) page on Novu.
* Click on Add a Provider.
* Select Postmark service.
* Enter the Postmark API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* Now is possible to send notifications using Postmark in Novu.


# Resend
Source: https://v0.x-docs.novu.co/channels-and-providers/email/resend

Learn how to use the Resend provider to send email notifications using Novu

You can use the [Resend](https://resend.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Resend provider in the email channel, you will need to create a Resend account and add your API key to the Resend integration on the Novu platform.

# Generating an API Key

To generate a new API key in Resend, you can follow these steps:

* [Sign up](https://resend.com/secret) or [Log in](https://resend.com/login) to your Resend account.
* Click on the **API Keys** link in the left sidebar, and then click the "Create API Key" button on the top right part of the page.
* On the [API Keys](https://resend.com/api-keys) page, click the **Create API Key** button.
* Give the API key a name and click on the **Add** button.
* Copy the generated API Key.

# Authenticating your Sender Identity

Before you can send emails on a large scale, you will need to authenticate your Sender Identity.

Resend allows you to authenticate your sender identity using [Domain Authentication](https://resend.com/docs/dashboard/domains/introduction).

# Creating a Resend integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-resend) page on Novu.
* Click on Add a Provider.
* Select Resend service.
* Enter your Resend API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
  * For testing, you can use `onboarding@resend.dev` if you have not authenticated your sender identity.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Resend in Novu.


# SendGrid
Source: https://v0.x-docs.novu.co/channels-and-providers/email/sendgrid

Learn how to use the Sendgrid provider to send email notifications using Novu

You can use the [SendGrid](https://sendgrid.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Sendgrid provider in the email channel, you will need to create a Sendgrid account and add your API key to the SendGrid integration on the Novu platform.

## Generating an API Key

To generate a new API key in SendGrid, follow these steps:

* Log in to your SendGrid account.
* Click on the **Settings** gear icon in the top right corner of the screen, and then click "API Keys" from the drop-down menu.
* On the API Keys page, click the **Create API Key** button.
* Give the API key a name and select the following permissions
* **Mail Send** - Full Access
* (Optional) Template Engine - Read Only
* Click the **Create & View** button to generate the API key. The key will be displayed on the screen, but you will only be able to view it once, so make sure to save it in a safe place.

NOTE

The access level of the key will determine what actions the API Key can take, so please choose the correct one.

* **Mail Send** - Full Access
* (Optional) Template Engine - Read Only

## Authenticating your [Sender Identity](https://docs.sendgrid.com/for-developers/sending-email/sender-identity)

Before you can send emails on a large scale, you will need to authenticate your Sender Identity. This is due to the latest regulatory changes regarding SPAM rules and email fraud. Most of the providers including Sendgrid require you to authenticate your Sender Identity before you can send emails.

SendGrid allows you to authenticate your sender identity using one of the following methods:

* [Single Sender Verification](https://docs.sendgrid.com/ui/sending-email/sender-verification) - This is the easiest way to authenticate your sender identity.
* [Entire Domain Authentication](https://docs.sendgrid.com/ui/account-and-settings/how-to-set-up-domain-authentication) - This is recommended if you are sending emails from multiple accounts under your domain.

## SendGrid integration with Novu

* Visit the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-sendgrid) on the Novu web dashboard.
* Click on Add a Provider.
* Select SendGrid service.
* Enter your SendGrid API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications through SendGrid using Novu.

## Using SendGrid template

Novu has its own email editor for writing email template. If you want to use pre made template from SendGrid, you can use `customData` filed of email overrides to send template details. Make sure your `Api Key` has enough permission to read and process the template.

<Info>customData override is available from version 0.21.0</Info>

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.trigger("workflowIdentifier", {
      to: "subscriberId",
      payload: {},
      overrides: {
        email: {
          customData: {
            // sendgrid template templateId
            templateId: 'sendgrid-template-id',
            // sendgrid template variables
            dynamicTemplateData: {
              total: '$ 239.85',
              items: [{
                  text: 'New Line Sneakers',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png',
                  price: '$ 79.95',
                },
                {
                  text: 'Old Line Sneakers rlfjrjrh4hr4rh4',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png',
                  price: '$ 79.95',
                },
              ],
              receipt: true,
              name: 'Sample Name',
              address01: '1234 Fake St.',
              address02: 'Apt. 123',
              city: 'Place',
              state: 'CO',
              zip: '80202',
            },
          },
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl --location 'https://api.novu.co/v1/events/trigger' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <NOVU_API_KEY>' \
    --data '{
        "name": "workflowIdentifier",
        "to":  ["subscriberId"],
        "payload": {},
        "overrides": {
            "email": {
                "customData": {
                    "templateId": "sendgrid-template-id",
                    "dynamicTemplateData": {
                        "total": "$ 239.85",
                        "items": [
                            {
                                "text": "New Line Sneakers",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png",
                                "price": "$ 79.95"
                            },
                            {
                                "text": "Old Line Sneakers rlfjrjrh4hr4rh4",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png",
                                "price": "$ 79.95"
                            }
                        ],
                        "receipt": true,
                        "name": "Sample Name",
                        "address01": "1234 Fake St.",
                        "address02": "Apt. 123",
                        "city": "Place",
                        "state": "CO",
                        "zip": "80202"
                    }
                }
            }
        }
    }'
    ```
  </Tab>
</Tabs>


# Sendinblue
Source: https://v0.x-docs.novu.co/channels-and-providers/email/sendinblue

Learn how to use the Sendinblue provider to send email notifications using Novu

You can use the [Sendinblue](https://www.sendinblue.com/) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the Sendinblue provider in the email channel, you will need to create a Sendinblue account and add your API key to the Sendinblue integration on the Novu platform.

# Finding the API Key

* To find your Sendinblue API key, log into your Sendinblue account and navigate to the [API Keys](https://account.sendinblue.com/advanced/api) page.

# Authenticating your sender identity

Before you can send emails on a large scale, you will need to authenticate your sender's identity. This is due to the latest regulatory changes regarding SPAM rules and email fraud. Most of the providers including Sendinblue require you to authenticate your sender identity before you can send emails.

Sendinblue allows you to authenticate your sender identity using one of the following methods:

* [Single Sender Verification](https://account.sendinblue.com/senders) - This is the easiest way to authenticate your sender identity.
* [Entire Domain Authentication](https://help.sendinblue.com/hc/en-us/articles/115000185270-What-is-a-verified-domain-on-Sendinblue-) - This is recommended if you are sending emails from multiple accounts under your domain.

# Creating a Sendinblue integration with Novu

* Visit the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-sendinblue) on the Novu web dashboard.
* Click on Add a Provider.
* Select Sendinblue service.
* Enter your Sendinblue API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Sendinblue in Novu.

## Using Sendinblue template

Novu has its own email editor for writing email template. If you want to use pre made template from Sendinblue, you can use `customData` filed of email overrides to send template details. Make sure your `Api Key` has enough permission to read and process the template.

<Info>customData override is available from version 0.21.0</Info>

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.trigger("workflowIdentifier", {
      to: "subscriberId",
      payload: {},
      overrides: {
        email: {
          customData: {
            // sendinblue template templateId
            templateId: 1,
            // sendinblue template variables
            templateParams: {
              total: '$ 239.85',
              items: [{
                  text: 'New Line Sneakers',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png',
                  price: '$ 79.95',
                },
                {
                  text: 'Old Line Sneakers rlfjrjrh4hr4rh4',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png',
                  price: '$ 79.95',
                },
              ],
              receipt: true,
              name: 'Sample Name',
              address01: '1234 Fake St.',
              address02: 'Apt. 123',
              city: 'Place',
              state: 'CO',
              zip: '80202',
            },
          },
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId",
      tenant: "tenantIdentifier"
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl --location 'https://api.novu.co/v1/events/trigger' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <NOVU_API_KEY>' \
    --data '{
        "name": "workflowIdentifier",
        "to":  ["subscriberId"],
        "payload": {},
        "overrides": {
            "email": {
                "customData": {
                    "templateId": 1,
                    "templateParams": {
                        "total": "$ 239.85",
                        "items": [
                            {
                                "text": "New Line Sneakers",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png",
                                "price": "$ 79.95"
                            },
                            {
                                "text": "Old Line Sneakers rlfjrjrh4hr4rh4",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png",
                                "price": "$ 79.95"
                            }
                        ],
                        "receipt": true,
                        "name": "Sample Name",
                        "address01": "1234 Fake St.",
                        "address02": "Apt. 123",
                        "city": "Place",
                        "state": "CO",
                        "zip": "80202"
                    }
                }
            }
        }
    }'
    ```
  </Tab>
</Tabs>


# Sparkpost
Source: https://v0.x-docs.novu.co/channels-and-providers/email/sparkpost

Learn how to use the Sparkpost provider to send email notifications using Novu

You can use the [SparkPost](https://messagebird.com/email/cloud-sending) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the SparkPost provider in the email channel, you will need to create a SparkPost account and add your API key to the SparkPost integration on the Novu platform.

# Generating an API Key

To generate a new API key in SparkPost, you can follow these steps:

* [Sign up](https://app.sparkpost.com/join) or [Log in](https://app.sparkpost.com/auth) to your SparkPost account.

  > During sign up, note that SparkPost is available in multiple regions. "SparkPost" refers to the SparkPost service hosted in North America. "SparkPost EU" refers to the SparkPost service hosted in Western Europe. An account created with SparkPost cannot be used with SparkPost EU, and vice-versa. You may use accounts in both regions.
  >
  > \~ *[SparkPost Documentation](https://support.sparkpost.com/docs/getting-started/getting-started-sparkpost/)*
* Click on the **Configuration** link on the navbar, and then click the "API Keys" link that pops up from the available options.
* On the [API Keys](https://app.sparkpost.com/account/api-keys) page, click the **Create API Key** button.
* Give the API key a name and click on the **Create API key** button.
* Copy the generated API Key.

# Authenticating your Sender Identity

Before you can send emails on a large scale, you will need to authenticate your Sender Identity.

SparkPost allows you to authenticate your sender identity using [Sending Domains](https://app.sparkpost.com/domains/list/sending).

# Creating a SparkPost integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sparkpost) page on Novu.
* Click on Add a Provider.
* Select SparkPost service.
* Enter your SparkPost API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Toggle the `eu` switch to true if you're in Western Europe
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using SparkPost in Novu.


# Introduction
Source: https://v0.x-docs.novu.co/channels-and-providers/in-app/introduction

Learn how to integrate In-App notification center and send In-App notification using Novu

In-app notifications are messages or alerts that appear within a mobile app or website while a user is actively using it. Unlike push notifications, which can reach users even when they're not actively engaged with an app, in-app notifications are designed to enhance the user experience within the app itself. Here's why they are important:

1. User Engagement: In-app notifications can keep users engaged and informed while they are using your app, providing valuable updates, reminders, or information relevant to their current activity. This can improve user satisfaction and encourage them to spend more time within the app.

2. Personalization: In-app notifications can be highly personalized based on a user's behavior, preferences, or location within the app. This personalization can lead to a more tailored and relevant user experience, increasing the likelihood of conversions or desired actions.

3. Onboarding and Education: In-app notifications are useful for guiding users through the app's features and functions, helping newcomers understand how to use the app effectively. They can also provide tips, tutorials, and educational content to enhance user proficiency.

4. Feedback and Surveys: In-app notifications can prompt users to provide feedback, complete surveys, or rate the app. Gathering user feedback within the app allows for real-time insights and improvements, contributing to app quality and user satisfaction.

5. Transactional Updates: In e-commerce or service apps, in-app notifications are crucial for providing order confirmations, shipping updates, payment receipts, and other transaction-related information, ensuring users are kept informed about important actions they've taken within the app.

6. Reduced Interruption: Unlike push notifications, in-app notifications are less intrusive since they only appear when users are actively engaged with the app. This can lead to a more seamless and focused user experience.

7. User Retention: By delivering timely and relevant information, in-app notifications can help retain users and reduce churn rates. Users who find value in the app are more likely to continue using it over time.

8. A/B Testing and Optimization: In-app notifications can be A/B tested to determine which messages and designs are most effective in achieving specific goals, such as increasing conversions or user engagement.

## In-app notifications using Novu

<iframe />

Novu provides a pre built component to display in-app notifications for almost all web frameworks. You can use this component to display in-app notifications in your web app. If you don't want to use the pre built component, you can use the headless component to build your own in-app notification center. Read more about notification center [here](/notification-center/introduction).


# Integration Store
Source: https://v0.x-docs.novu.co/channels-and-providers/integration-store

Learn about Novu's integration store

## Introduction

Novu's integration store serves as the central hub from where you can seamlessly enable and disable various services for efficient communication.

This feature simplifies the process of managing your communication channels. You can see which provider is enabled/disabled for what channel, which provider works in what environment and more. Moreover, it provides a clear overview of enabled and disabled services, offering you greater control over your communication strategy.

<Frame>
  <img />
</Frame>

From this image above, you can see that I've configured `Sendgrid` and `Twilio` as my email and sms provider respectively and both are in the `development` environment.

## Streamline Communication Services

With the Integration Store, you can streamline your communication services effortlessly. Whether it's Email, Chat, or SMS, this feature allows you to integrate different communication channels with ease. This centralization ensures that you can manage all your services conveniently from a single location.

## Enabling and Disabling Services

The Integration Store allows you to activate or deactivate specific services according to your communication needs. You can enable a service by simply entering the required `API key`, `identifier` and other required info depending on the provider you're choosing. Conversely, if you need to deactivate a service temporarily or make changes, you can disable it just as effortlessly.

## Enhanced Flexibility

By providing a comprehensive range of communication services under one roof, the Integration Store enhances your flexibility. You have the power to customize your communication strategy by enabling the services that align with your requirements.

## Conclusion

Novu's integration store offers a centralized and user-friendly platform for managing your communication services effectively. With its categorization, clear visibility, and easy enablement/disabling of services, you can fine-tune your communication strategy and streamline your interactions, enhancing the overall communication experience of your product.


# Overview
Source: https://v0.x-docs.novu.co/channels-and-providers/introduction

Learn about what channels, providers and oganizations are

## Channels:

Novu lets you send notifications across different communication mediums, including emails, in-app messages, push notifications, SMS, and chat. Each of these five communication mediums is referred to as a notification ‘channel’.

<Frame>
  <img />
</Frame>

## Providers:

Providers are what allow us to handle message delivery over multiple channels. Of the five notification channels that Novu currently supports, each channel except the ‘in-app’ channel has multiple providers.

The in-app channel only has one provider (the default Novu provider).

All the remaining channels have multiple providers.

## Organizations:

Organizations enable you to segregate notifications across multiple products that you may have. You can use Novu to send notifications across multiple apps and can create organizations.

<Frame>
  <img />
</Frame>

<Warning>Credentials are saved per instance of the active integrations of a provider. In case of more than one active provider of the same type, If `integrationIdentifier` is not sent in [this](https://docs.novu.co/api-reference/subscribers/update-subscriber-credentials) API, then the most recently created provider will be used to update the credentials.</Warning>


# Apple Push Notification Service (APNS)
Source: https://v0.x-docs.novu.co/channels-and-providers/push/apns

Learn how to use the Apple Push Notification Service (APNS) provider to send push notifications using Novu

[Apple Push Notification Service](https://docs.expo.dev/push-notifications/overview/), as the name suggests, is a notification delivery service provided by Apple.

Apple provides two authentication methods to make a secure connection to APNs. The first is Certificate-Based Authentication (using a .p12 certificate). The second is Token-Based Authentication (using a .p8 key). We'll make use of the **.p8** key.

To enable APNS integration, you need to create an [Apple Developer](https://developer.apple.com/) account with an [Admin role](https://appstoreconnect.apple.com/access/users).

To generate the p8 key for your account:

1. Head over to **Certificates, Identifiers & Profiles > Keys**.
2. Register a new key and give it a name.
3. Enable the Apple Push Notifications service (APNs) checkbox by selecting it.
4. Click the **Continue** button and on the next page, select **Register**.
5. Download the **.p8** key file.

You also need the following to connect to APNs:

1. **Key ID** - This is a 10-character unique identifier for the authentication key. You can find it in the key details section of the newly created key in your Apple developer account.
2. **Team ID** - This is available in your Apple developer account.
3. **Bundle ID** - This is the ID of your app. You can find it in the app info section of your Apple developer account.

The overrides field supports all [Notification payload](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/generating_a_remote_notification?language=objc) values, as shown below:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    abc: 'def', // If the notification is a data notification, the payload will be sent as the data
  },
  overrides: {
    apns: {
      payload: {
        aps: {
          notification: {
            title: 'Test',
            body: 'Test push',
          },
          data: {
            key: 'value',
          },
        },
      },
    },
  },
});
```

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    key1: 'val1',
    key2: 'val2', // If the notification is a data notification, the payload will be sent as the data
  },
  overrides: {
    type: 'data',
    apns: {
      headers: {
        'apns-priority': '5',
      },
      payload: {
        aps: {
          alert: {
            'loc-key': 'GAME_PLAY_REQUEST_FORMAT',
            'loc-args': ['Shelly', 'Rick'],
          },
          sound: 'demo.wav',
        },
      },
    },
  },
});
```

Before triggering the notification to a subscriber(user) with push as a step in the workflow, make sure you have added the subscriber's device token as follows:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.APNS, {
      deviceTokens: ['token1', 'token2'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "apns",
      "deviceTokens": ["token1", "token2"],
      "integrationIdentifier": "apns-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.


# Expo Push
Source: https://v0.x-docs.novu.co/channels-and-providers/push/expo-push

Learn how to use the Expo push provider to send push notifications using Novu

[Expo Push](https://docs.expo.dev/push-notifications/overview/) is a notification delivery service provided by Expo.

To enable Expo Push integration, you need to create an [Expo Application Services (EAS)](https://expo.dev/)account and generate an access token in the EAS dashboard.

The overrides field supports all [Message Request](https://docs.expo.dev/push-notifications/sending-notifications/#message-request-format) values. An example of the same follows:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    abc: 'def',
  },
});
```

Before triggering the notification to a subscriber(user) with push as a step in the workflow, make sure you have added the subscriber's device token as follows:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,PushProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.EXPO, {
      deviceTokens: ['token1', 'token2'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "expo",
      "deviceTokens": ["token1", "token2"],
      "integrationIdentifier": "expo-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.


# Firebase Cloud Messaging (FCM)
Source: https://v0.x-docs.novu.co/channels-and-providers/push/fcm

Learn how to use the Firebase Cloud Messaging (FCM) provider to send push notifications using Novu

[Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging) is a free notification delivery service provided by Google Firebase.

To enable the FCM integration, you need to get your service account key from the [Firebase Console](https://console.firebase.google.com/).

## Generating a Service Account Key JSON

To acquire the account key JSON file for your service account

1. Select your project, and click the gear icon on the top of the sidebar.
2. Head to project settings.
3. Navigate to the service account tab.
4. Click **Generate New Private Key,** then confirm by clicking **Generate Key.**
5. Clicking **Generate Key** downloads the JSON file.

After that, paste the entire JSON file content in the Service Account field of the FCM provider in the integration store on Novu’s web dashboard.

Make sure your service account json content contains these fields

```json theme={null}
{
  "type": "service_account",
  "project_id": "PROJECT_ID",
  "private_key_id": "PRIVATE_KEY_ID",
  "private_key": "PRIVATE_KEY",
  "client_email": "FIREBASE_ADMIN_SDK_EMAIL",
  "client_id": "CLIENT_ID",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "CLIENT_X509_CERT_URL"
}
```

## FCM Overrides

The overrides field supports apns, android, webpush and fcmOptions overrides

| Override Field | Type / Interface | Link                                                                                                                                                                                         |
| -------------- | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| android        | AndroidConfig    | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.androidconfig](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.androidconfig) |
| apns           | ApnsConfig       | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.apnsconfig](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.apnsconfig)       |
| webPush        | WebpushConfig    | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.webpushconfig](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.webpushconfig) |
| fcmOptions     | FcmOptions       | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.fcmoptions](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.fcmoptions)       |

## Setting Device Token

Before triggering the notification to a subscriber(user) with push as a step in the workflow, make sure you have added the subscriber's device token as follows:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      PushProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials(
      'subscriberId', 
      PushProviderIdEnum.FCM, 
      { deviceTokens: ['token1', 'token2'] }, 
      'fcm-MnGLxp8uy'
    );
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "fcm",
      "credentials": {
        "deviceTokens" : [
          "token1", 
          "token2"
        ]
      },
      "integrationIdentifier": "fcm-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

## SDK Trigger Example

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
  to: {
    subscriberId: "<SUBSCRIBER_ID>",
  },
  payload: {
    abc: "def", // If the notification is a data notification, the payload will be sent as the data
  },
  overrides: {
    fcm: {
      // type: 'data' => will turn this into an FCM data notification, where the payload is sent as a data notification. If the type is not set, you can use the "data" override to send notification messages with optional data payload
      type: "data",

      // URL of an image to be displayed in the notification.
      imageUrl: "https://domain.com/image.png",

      // If type is not set, you can use the "data" override to send notification messages with optional data payload
      data: {
        key: "value",
      },

      // Check FCM Overrides section above for these types
      android: {},
      apns: {},
      webPush: {},
      fcmOptions: {},
    },
  },
});
```

Device/notification identifiers can be set by using [setCredentials](#set-device-token) or by using the `deviceIdentifiers` field in overrides.

<Info> Novu uses FCM version V1</Info>

## Relative Link in Webpush

Suppose you’re using the Firebase (FCM) provider to send push notifications to web browsers via Novu and want users to be returned to the website after clicking the notification.

In that case, you must use the `link` property with a relative URL.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from "@novu/node";

    const novu = new Novu("<NOVU_API_KEY>");

    novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
      to: {
        subscriberId: "<SUBSCRIBER_ID>",
      },
      payload: {
        abc: "def", // If the notification is a data notification, the payload will be sent as the data
      },
      overrides: {
        fcm: {
          webPush: {
            fcmOptions: {
              link: "/foo",
            },
          },
        },
      },
    });
    ```
  </Tab>

  <Tab title="Curl">
    ```bash theme={null}
    curl --location --request POST 'https://url.to.our.selfhosted.novu' \
        --header 'Authorization: ApiKey KEY' \
        --header 'Content-Type: application/json' \
        --data-raw '{
            "name": "workflow-name",
            "to": {
                ...
            },
            "overrides": {
              "fcm": {
                "webPush": {
                  "fcm_options": {
                    "link": "/foo"
                  }
                }
              }
            }
          }'
    ```
  </Tab>
</Tabs>

## FCM Cost

As per Firebase [pricing](https://firebase.google.com/pricing), **Cloud Messaging** product is free of cost to use. If other Firebase products are used, the cost will be charged as per the product.

## FAQs

<AccordionGroup>
  <Accordion title="The registration token is not a valid FCM registration token">
    You may come across an error like so:

    ""Sending message failed due to "The registration token is not a valid FCM registration token""".

    This error happens because of invalid or stale token. The fix for this is to remove old tokens, generate a new token and save it into user subscribers.
  </Accordion>

  <Accordion title="FCM notifications sent successfully with no error but push notification is not received in device">
    Try to generate a new token after clearing device cache and retry with this fresh token.
  </Accordion>

  <Accordion title="Sending message failed due to 'Requested entity was not found'">
    This error occurs when your token is no longer valid. To fix this, generate a new token and use it.
  </Accordion>

  <Accordion title="Subscriber does not have a configured channel error">
    This error occurs if the fcm integration is active but subscriber is missing from the fcm credentials (deviceTokens). The credentials (deviceTokens) for the subscriber needs to be set.
  </Accordion>
</AccordionGroup>


# Onesignal
Source: https://v0.x-docs.novu.co/channels-and-providers/push/onesignal

Learn how to use the Onesignal provider to send push notifications using Novu

[OneSignal](https://onesignal.com/) is a paid push notification service that supports sending messages via both [Apple Push Notification Service](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server) (APNs) as well as [Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging) (FCM).

To configure the OneSignal integration, you will need an active account which has credentials for APNs, FCM or both, and have access to the `OneSignal App ID` and `Rest API Key` available via your [application's settings page](https://documentation.onesignal.com/docs/keys-and-ids).

# Setting the Device Token

Once OneSignal has been configured with your credentials for APNs/FCM, and the OneSignal SDK has been [set up and configured](https://documentation.onesignal.com/docs/onboarding-with-onesignal#step-1-setup-onesignal-sdk) for your application, your users will begin to be automatically assigned a unique OneSignal [player\_id](https://documentation.onesignal.com/docs/users#player-id) identifier by the SDK.

This identifier allows targeting your user when sending push notifications without having to retrieve the specific Android or iOS device tokens - which are managed by OneSignal.

In order to target the OneSignal user from Novu, you must register the OneSignal `player_id`as the `deviceToken` for your Novu subscriber. This value can be retrieved via the [OneSignal SDK](https://documentation.onesignal.com/docs/users-and-devices#finding-users) for your platform.

Once you have the user's `player_id` value, the `deviceToken` for your Novu subscriber can be set via:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.OneSignal, {
      // Your user's unique 'player_id' from OneSignal
      deviceTokens: ['ad0452ca-3ca7-43b5-bf9b-fa93fd322035'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "one-signal",
      "deviceTokens": ["ad0452ca-3ca7-43b5-bf9b-fa93fd322035"],
      "integrationIdentifier": "one-signal-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

# SDK Trigger Example

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    abc: 'def', // If the notification is a data notification, the payload will be sent as the data
  },
});
```

Device/notification identifiers can be set by using [setCredentials](https://docs.novu.co/channels/email/resend/#set-device-token) or by using the `deviceIdentifiers` field in overrides.


# Push Channel Introduction
Source: https://v0.x-docs.novu.co/channels-and-providers/push/overview

Learn how to send push notifications with Novu using external providers like FCM, Expo etc.

Push notifications are short, targeted messages delivered to a user's device or browser, often through mobile apps or websites. They serve as a powerful communication tool, offering real-time updates, reminders, and personalized content. Push notifications can range from news alerts and social media updates to promotional offers and important app notifications.

These messages are designed to engage users and keep them informed about relevant events or activities, even when they are not actively using an app or browsing a website. They play a crucial role in user engagement and retention for businesses and organizations, as they can re-engage users and prompt them to take specific actions.

Novu can be used to deliver push notifications to your customers devices using a unified delivery API. Both Mobile and Web push notifications are supported.

## Using push channel with Novu

To send a push notification to subscribers (users) using Novu:

* Add a push channel provider in integration store
* Add push channel as a step in existing or new workflow.
* Add static or dynamic content using variables in push step fields
* Store provider specific device tokens/identifiers in subscriber profile. Read provider specific documentation on how to obtain and store device tokens.
* Make sure all provider specific steps are configured properly before triggering workflow. Read provider related documentation for all required steps.
* Trigger the workflow.

## Supported providers

* [Firebase Cloud Messaging (FCM)](/channels-and-providers/push/fcm)
* [Expo Push](/channels-and-providers/push/expo-push)
* [Apple Push Notification Service](/channels-and-providers/push/apns)
* [OneSignal](/channels-and-providers/push/onesignal)
* [Pushpad](/channels-and-providers/push/pushpad)
* [Push Webhook](/channels-and-providers/push/push-webhook)

<Note>Novu supports multiple active providers for push channel.</Note>

<Tip>
  <MissingProvider />
</Tip>

## Managing push device tokens

To send push notifications to subscribers, you need to store device tokens or identifiers in subscriber profiles. These tokens are unique identifiers that help push notification providers deliver messages to the correct devices. Each provider has its own method for obtaining and storing device tokens.

Novu offers to ways of keeping your device tokens in sync with subscriber profiles:

* Just-in-time: Pass device tokens in the payload when triggering a workflow. Novu will automatically update subscriber profiles with the new device tokens.
* Manual: Update subscriber profiles with device tokens using the Novu Set Credentials API.

### Just-in-time

When triggering a workflow, you can pass the `channels` array on the subscriber object with the device tokens for the push provider of your choice. Here is an example with fcm:

```typescript theme={null}
novu.trigger('workflow-id', {
  to: {
    subscriberId: 'subscriber-id',
    channels: [
      {
        providerId: 'fcm',
        credentials: {
          deviceTokens: ['token-1', 'token-2'],
        },
      },
    ],
  },
  payload: {},
});
```

### Manual

Use the Novu Set Credentials API to update subscriber profiles with device tokens. You can read more about the API in the [API Reference](/api-reference/subscribers/update-subscriber-credentials) or the [FCM Example](/channels-and-providers/push/fcm#setting-device-token)

## Frequently Asked Questions

### How to remove one device token from subscriber credentials?

To remove a device token from subscriber credentials, you need to get the current device tokens from subscriber credentials, remove all deviceTokens, remove the token you want to remove and then update the subscriber credentials with new device tokens.

<Tabs>
  <Tab title="Node.js">
    ```ts theme={null}
    import { Novu, PushProviderIdEnum } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    // fetch subscriber details
    const subscriber = await novu.subscribers.get('subscriberId');

    // get current device tokens from subscriber credentials for the provider
    const currentDeviceTokens = subsciber.data.data.channels.find(
        // _integrationId can also be checked in place of providerId ;
        (channel) => channel.providerId === PushProviderIdEnum.FCM,
    ).credentials.deviceTokens;

    // remove all device tokens
    await this.novu.subscribers.setCredentials(
        'subscriberId',
        PushProviderIdEnum.FCM,
        { deviceTokens: [] },
    );

    // remove the token you want to remove
    const newDeviceTokens = currentDeviceTokens.filter(
        (token) => token !== 'token-to-be-removed',
    );

    // update subscriber credentials with new device tokens
    await this.novu.subscribers.setCredentials(
        'subscriberId',
        PushProviderIdEnum.FCM,
        { deviceTokens: newDeviceTokens },
    );
    ```
  </Tab>
</Tabs>


# Push Webhook
Source: https://v0.x-docs.novu.co/channels-and-providers/push/push-webhook

Learn how to use the Push Webhook provider to send  notifications using Novu

Push Webhook provider is a bit different different from other push providers as it does not depend on other third party services.
Users can use their own api url as webhook url and novu will make a post request on that webhook url.

## Steps To Configure

1. Go to [integration store](https://web.novu.co/integrations?utm_campaign=docs-push-webhook) and click on `Add a provider` button. Choose `Push` channel and then `Push Webhook` provider.
2. Enter your Webhook URL. For quick testing use [this](https://webhook.site/) website.
3. Enter Secret Hmac Key. Novu will use this secret hmac key to encrypt the data using `HMAC SHA256` algorithm and send the hash as value of `x-novu-signature` header. User can use `x-novu-signature` header to test authenticity of the request. Read more [here](#checking-authenticity)
4. Click on the update button.
5. Update the subscriber credentials using SDK or API. Read more [here](#set-device-token)

<Info>Your webhook url should accept `POST` request.</Info>

## Set Device Token

This step is a mandatory step. Other push providers have third party dependencies where a device token can be generated. But in case of push webhook provider, there is no any way to generate device token. Any random string can be used as device token.

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    // PushProviderIdEnum.PushWebhook = push-webhook
    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.PushWebhook, {
      deviceTokens: ['ANY_RANDOM_STRING'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "push-webhook",
      "deviceTokens": ['ANY_RANDOM_STRING'],
      "integrationIdentifier": "push-webhook-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

## Example paylod sent by novu to webhook url

```json theme={null}
{
  "target": [
    "subscriber-token-for-push-webhook-provider"
  ],
  "title": "Push Webhook message title",
  "content": "push Webhook content body",
  "overrides": {
    "data": {
      "custom_message": "this is custom message from payload push webhook demo",
    }
  },
  "payload": {
    "custom_message": "this is custom message from payload push webhook demo",
    "__source": "test-workflow",
    "subscriber": {
      // subscriber fields
      "_id": "65c0d71c0959a38e8857b131",
      "_organizationId": "organizationId",
      "_environmentId": "environmentId",
      "firstName": "Pawan",
      "lastName": "Jain",
      "phone": "+123456789",
      "subscriberId": "push-webhook-demo-subscriber-id",
      "email": "pawan+push+web+hook+demo@domain.com",
      "channels": [
        {
          "credentials": {
            "deviceTokens": [
              "subscriber-token-for-push-webhook-provider"
            ]
          },
          "_integrationId": "integrationId",
          "providerId": "push-webhook"
        }
      ],
      "data": {
        // custom data field of subscriber
        "isDeveloper": "true"
      },
      "deleted": false,
      "createdAt": "2024-02-05T12:39:56.379Z",
      "updatedAt": "2024-02-05T12:54:08.684Z",
      "__v": 0,
      "id": "65c0d71c0959a38e8857b131"
    },
    "step": {
      // digest variables
      "digest": false,
      "events": [],
      "total_count": 0
    }
  }
}
```

## Checking Authenticity

```typescript theme={null}
import crypto from "crypto"

// secret key added in step 3
const secretKey = "YOUR_HMAC_SECRET_KEY"

// function to handle webhook url route request
async acceptNovuPushWebHookRequest(request, response){

  const payloadSentByNovu = request.body
  const hmacHashSentByNovu = request.headers['x-novu-signature']

  const actualHashValue = crypto
    .createHmac('sha256', secretKey)
    .update(payloadSentByNovu, 'utf-8')
    .digest('hex');

  if(hmacHashSentByNovu === actualHashValue){
    // handle the notification
    console.log("Request sent by Novu")
  } else {
    throw new Error("Not a valod request")
  }
}
```


# Pusher Beams
Source: https://v0.x-docs.novu.co/channels-and-providers/push/pusher-beams

Learn how to use the Pusher Beams provider to send push notifications using Novu

[Pusher Beams](https://pusher.com/beams/) is a cross-platform push notification API service provided by Pusher.

To enable Pusher Beams integration, you need to create a Pusher Beams Instance and use both `Instance ID` and `Secret Key` from the Instance [dashboard](https://dashboard.pusher.com/beams/).

# Setting the Device Token

Once Pusher Beams instance has been created, and the Pusher Beams SDK has been [set up and configured](https://pusher.com/docs/beams/reference/all-libraries/) for your application, you can associate users with their devices using [Authenticated Users](https://pusher.com/docs/beams/guides/publish-to-specific-user/web/).

This identifier allows targeting your user when sending push notifications without having to retrieve the specific Web, Android or iOS device tokens - which are managed by Pusher Beams.

In order to target the Pusher Beams user from Novu, you must register the Pusher Beams Authenticated Users with their `userId` as the `deviceToken` for your Novu subscriber. This value can be retrieved via [getUserId()](https://pusher.com/docs/beams/reference/web/#getuserid) method from the SDK for your platform.

Once you have the user's `userId` value, the `deviceToken` for your Novu subscriber can be set via:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.PusherBeams, {
      // Your user's unique 'userId' from Pusher Beams
      deviceTokens: ['userId-from-pusher-beams'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "pusher-beams",
      "deviceTokens": ['userId-from-pusher-beams'],
      "integrationIdentifier": "pusher-beams-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

# SDK Trigger Example

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    custom_data: 'custom_data', // the payload will be sent as notification data object. Cannot contain the key “pusher”
  },
});
```


# Pushpad
Source: https://v0.x-docs.novu.co/channels-and-providers/push/pushpad

Learn how to use the Pushpad provider to send web push notifications using Novu

[Pushpad](https://pushpad.xyz) is a web push service that supports sending notifications to all major browsers (Chrome, Firefox, Edge, Safari, etc.) via FCM, Mozilla autopush, Windows Push Notification Services and Apple Push Notification service, with just one simple API.

To configure the Pushpad integration, you will need an active account and you need to have a `Pushpad Auth Token` (from the [account settings](https://pushpad.xyz/access_tokens)) and the `Pushpad Project ID` (from the project settings).

# Setting the Device Token

Once Pushpad has been configured with your credentials and the Pushpad SDK has been [set up and installed](https://pushpad.xyz/docs/pushpad_pro_getting_started) on your website, you can [assign a user ID (uid)](https://pushpad.xyz/docs/identifying_users) to the push subscriptions.

This identifier (`uid` or `user ID`) allows targeting a specific browser when sending push notifications.

In order to target the Pushpad user from Novu, you must register the Pushpad `uid` as the `deviceToken` for your Novu subscriber. For example, if you invoked the [Pushpad JavaScript SDK](https://pushpad.xyz/docs/javascript_sdk_reference) with `pushpad('uid', 'user123')`, then `user123` is the user ID for that browser.

Once you have the `uid` value, the `deviceToken` for your Novu subscriber can be set using this code:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.Pushpad, {
      // the user ID (uid) that you used for Pushpad
      deviceTokens: ['user123'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "pushpad",
      "deviceTokens": ['user123'],
      "integrationIdentifier": "pushpad-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

# SDK Trigger Example

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {}
});
```

The devices of the subscriber that should receive the notifications can be set by using `setCredentials` or by using the `deviceIdentifiers` field in overrides.


# Africa's Talking
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/africas-talking

Learn how to use the Africa's Talking provider to send sms notifications using Novu

You can use [Africa's Talking](https://africastalking.com/) provider to send SMS messages to your customers using the Novu platform with a single API to create multi-channel experiences.

## Getting Started

To use Africa's Talking provider in the SMS channel, the first step is to create an Africa's Talking account and add your `API Key`, `username` and `Sender's ID` to Africa's Talking integration on the Novu platform.

## Creating a username

You’ll need to create an application to create a username in Africa’s Talking. To do so, follow the steps below:

* [Sign up](https://account.africastalking.com/auth/register) or [Log in](https://account.africastalking.com/auth/login) to your Africa's Talking account.
* Select the team you want your app to be in.

<Frame>
  <img />
</Frame>

* If you're a new user and don't have a team yet, you'll have to do so by clicking on New Team and entering your team name. Click on Save when you're done.

<Frame>
  <img />
</Frame>

* On the page that appears, click on the Create App button.
* On the pop-up that appears, enter your application name, username and select a country. Then click Save. The `username` is what you will use on the Novu platform.

<Frame>
  <img />
</Frame>

## Generating an API key

To generate a new API key, you can follow these steps:

<Note>
  Ensure you have created an app in your team.
</Note>

* Click on the app you created.

<Frame>
  <img />
</Frame>

* On the page that appears, click on Settings(on the menu on your left). This will display a dropdown. Click on API Key from the dropdown options.

<Frame>
  <img />
</Frame>

* On the page that appears, enter your password and click Generate.

<Frame>
  <img />
</Frame>

* Copy the API Key generated and paste it into the Novu platform or record it somewhere safe for later use because you will not see it from the dashboard on subsequent visits.

<Note>
  Once you've generated your API Key, wait about 3 minutes before testing it.
</Note>

## Getting your Sender's ID

Sender IDs allow you to brand your messages as you send them to your customers. There are two kinds of sender IDs, **shortcodes** and **alphanumerics**. The difference is that you can send and receive messages with shortcodes but only send messages with an alphanumeric.

To create a Short Code:

* On your app dashboard, click on SMS (on the menu on your left). This will display a dropdown. Click on `Shortcodes` from the dropdown options. This will also display a dropdown from which you can then click on `My Shortcodes` to view your codes.

<Frame>
  <img />
</Frame>

* If you have not created one yet, on the `Shortcodes` dropdown option, click on `Request`.
  On the page that appears, fill in the form and submit.

<Frame>
  <img />
</Frame>

## To create an Alphanumeric:

* On your app dashboard, click on SMS (on the menu on your left). This will display a dropdown. Click on `Alphanumerics` from the dropdown options. This will also display a dropdown from which you can then click on `My Alphanumerics` to view your codes.

<Frame>
  <img />
</Frame>

* If you have not created one yet, on the `Alphanumerics` dropdown option, click on `Request`.
  On the page that appears, fill in the form and submit

<Frame>
  <img />
</Frame>

* Once you're done, add either your short code or alphanumeric to the `from` field on the Novu platform.

## Creating an Africa's Talking integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-africastalking) page on Novu.
* Click the "Add a provider" button.
* Locate **Africa's Talking** under the SMS section and click on the **Connect** button.
* Enter the `API key`.
* Fill in the `username` field.
* Fill in the `from` field. This is your registered `short code` or `alphanumeric` value.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using Africa's Talking in Novu.


# AWS SNS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/aws-sns

Learn how to use the AWS SNS provider to send sms notifications using Novu

You can use the [AWS SNS](https://aws.amazon.com/sns/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To integrate AWS SNS on the Novu platform, you will need to have in AWS, an IAM user who has the `sns:Publish` permission.

# Create User

To create a user, log in to AWS Console and follow these steps:

* Go to the `IAM` service page.
* Create a new user with `sns:Publish` permission, or add `sns:Publish` permission to an existing user.
* Add the `Access Key` credential to the user and copy the `Access key ID` and the `Secret access key`.

For security reasons, it is suggested that you create a new User to use with Novu.

# Create an AWS SNS integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-sns) page on Novu.
* Click the "Add a provider" button.
* Locate **Amazon SNS** and click on the **Connect** button.
* Enter your `Access Key ID`, `Secret Access key`, and `AWS region`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Save** button.
* You should now be able to send SMS notifications using **Amazon SNS** in Novu.


# Azure SMS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/azure

Learn how to use the Azure SMS provider to send sms notifications using Novu

You can use the [Azure SMS](https://learn.microsoft.com/en-us/azure/communication-services/quickstarts/sms/send?tabs=windows\&pivots=platform-azcli) SMS provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use Azure SMS provider in the SMS channel, the first step is to create an Azure account and grab the communication services connection string from your account dashboard.

# Creating a Azure SMS integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-azure) page on Novu.
* Click the "Add a provider" button.
* Locate **Azure Sms** under the SMS section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `Connection string`.
* Enter the `From` value.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **Azure Sms** in Novu.


# BulkSMS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/bulk-sms

Learn how to use the BulkSMS provider to send sms notifications using Novu

You can use the [BurstSMS](https://bulksms.com/) provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use BulkSMS provider in the SMS channel, the first step is to create a BulkSMS account and create an [API token](https://www.bulksms.com/account/#!/advanced-settings/api-tokens).

# Creating a BulkSMS integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-bulksms) page on Novu.
* Click the "Add a provider" button.
* Locate **BulkSMS** under the SMS section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `API Token`.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **BulkSMS** in Novu.


# Clickatell
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/clickatell

Learn how to use the Clickatell provider to send sms notifications using Novu

You can use the [Clickatell](https://www.clickatell.com/) provider to send SMS messages to your customers using the Novu Platform.
Let's see how to do it:

## Getting Started

To use the [Clickatell](https://www.clickatell.com/) provider in the SMS channel, the first step is to [create a Clickatell account](https://www.clickatell.com/sign-up/) and add your API key to the Clickatell integration on the [Novu web dashboard](https://web.novu.co/integrations?utm_campaign=docs-sms-clickatell).

## Retrieving your API Key

To find your Clickatell API key:

* [Sign up](https://www.clickatell.com/sign-up/) or [Login](https://app.clickatell.com/signin) to your Clickatell account.
* Click on the `My Workspace`, and then click `SMS` in Channels Section.

<Frame>
  <img />
</Frame>

* Click on the `New SMS Setup`.

<Frame>
  <img />
</Frame>

* Select `API` then `Messaging Type` and click Next.

<Frame>
  <img />
</Frame>

* Select `Basic HTTP API` then `create a new HTTP API` and click Next.

<Frame>
  <img />
</Frame>

* Now fill in all details and Click Next.

<Frame>
  <img />
</Frame>

* Copy the API key and click complete.

<Frame>
  <img />
</Frame>

## Create a Clickatell integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-clickatell) page on Novu.
* Click the "Add a provider" button.
* Locate **Clickatell** under the SMS section and click on the **Connect** button.
* Enter your Clickatell API Key.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Clickatell** in Novu.


# Firetext
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/firetext

Learn how to use the firetext provider to send sms notifications using Novu

You can use the [firetext](https://www.firetext.co.uk) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the firetext provider in the SMS channel, the first step is to create a firetext account and add your API key and Sender ID to the firetext integration on the Novu platform.

* Note : Firetext is only available in uk region. Others may require additional verification.

## Retrieving your API Key

To find your firetext API key:

* [Sign up](https://app.firetext.co.uk/signup) or [Login](https://app.firetext.co.uk/) to your firetext account.
* Click on the `Settings` icon in the top right corner of the screen.

<Frame>
  <img />
</Frame>

* Now Click on the `API` in `My Settings` Section.

<Frame>
  <img />
</Frame>

* On the API Keys page, copy the `API key`.

<Frame>
  <img />
</Frame>

## Create a firetext integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-firetxt) page on Novu.
* Click the "Add a provider" button.
* Locate **firetext** under the SMS section and click on the **Connect** button.
* Enter your `firetext` API Key.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **firetext** in Novu.


# gupshup
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/gupshup

Learn how to use the gupshup provider to send sms notifications using Novu

You can use the [gupshup](https://www.gupshup.io/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the gupshup provider in the SMS channel, the first step is to create a gupshup account and add the Account Username and Password to the gupshup integration on the Novu platform.

# What is User id and Password?

* `userid` : The account number provided by the Enterprise SMS GupShup.
* `Password` : Password is provided by Gupshup for authentication of user id. The password must be the same as used to log on to the Enterprise SMS GupShup website.

# Creating a gupshup integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-gupshup) page on Novu.
* Click the "Add a provider" button.
* Locate **gupshup** under the SMS section and click on the **Connect** button.
* Enter the `User id`.
* Enter the `Password`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **gupshup** in Novu.


# Infobip - SMS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/infobip

Learn how to use the Infobip provider to send sms notifications using Novu

You can use the [Infobip](https://www.infobip.com/developers/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Infobip provider in the SMS channel, you will need to create an Infobip account and add your API key and Base URL to the Infobip integration on the Novu platform.

## Retrieving your API Key

To Find a new API key in Infobip, you can follow these steps:

* [Sign up](https://www.infobip.com/signup) or [Log in](https://portal.infobip.com/login/) to your Infobip account.
* On the [Homepage](https://portal.infobip.com/homepage/), you'll see your API key.

<Frame>
  <img />
</Frame>

Alternatively, you can find the API key on the Developer Tools page.

* On the sidebar (on the left), click on `Developer Tools`.
* This will display a dropdown from which you can then click on `API Ksys` to view your API key.

<Frame>
  <img />
</Frame>

If you want to create an API key:

* Click on the `CREATE API KEY` button
* Fill the form
* Click on `GENERATE`

<Frame>
  <img />
</Frame>

## Finding the Base URL

To see your base URL, log in to the account. Once logged in, on the Homepage, you should see your base URL in this format: `xxxxx.api.infobip.com`.

<Frame>
  <img />
</Frame>

## Create an Infobip integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-infobip) page on Novu.
* Click the "Add a provider" button.
* Locate **Infobip** under the SMS section and click on the **Connect** button.
* Enter your Infobip API Key.
* Enter your Base URL.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

You should now be able to send SMS notifications using Infobip in Novu.


# MessageBird
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/messagebird

Learn how to use the messagebird provider to send sms notifications using Novu

You can use the [MessageBird](https://www.messagebird.com) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the MessageBird provider in the SMS channel, the first step is to create a [MessageBird account](https://www.messagebird.com/en/sign-up) and then generate an `Access Key` within the developers' section section of your MessageBird account. This access key is essential for authenticating your requests to the MessageBird API.

# Creating a MessageBird integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-messagebird) page on Novu.
* Click the "Add a provider" button.
* Locate **MessageBird** under the SMS section. Click it and the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `Access Key` value.
* Enter the `From` value.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **MessageBird** in Novu.


# Nexmo
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/nexmo

Learn how to use the Nexmo provider to send sms notifications using Novu

You can use the [Nexmo By Vonage](https://www.vonage.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Nexmo provider in the SMS channel, the first step is to create a Nexmo account and add the API key and API Secret to the Nexmo integration on the Novu platform.

# Finding the API key and secret

First, [sign up for a Vonage account](https://ui.idp.vonage.com/ui/auth/login) if you don't already have one, and make a note of your API key and secret on the [dashboard getting started page](https://dashboard.nexmo.com/getting-started-guide).

# Create a Nexmo integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-nexmo) page on Novu.
* Click the "Add a provider" button.
* Locate **Nexmo** under the SMS section and click on the **Connect** button.
* Enter the `API key` and `API Secret`.
* Enter a valid `From` email address.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.
* Now it is possible to send SMS notifications using **Nexmo** in Novu.


# SMS Channel Overview
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/overview

Learn the process of configuring and using sms providers with Novu

Novu can be used to deliver sms messages to your customers using a unified delivery API. You can easily integrate your favorite sms provider using the built-in integration store.

<iframe />

## Configuring SMS providers

When creating a SMS provider integration you will be asked to provide additional fields alongside the provider-specific credentials:

* **From** - Will be displayed as the sender of the SMS

Additional credentials can be API key, username, password or other provider specific credentials.

<Note>
  Some countries have strict restriction of using verified `from` sender id
  (name). Kindly check country and provider specific requirements first.
</Note>

## Sending SMS Overrides

The overrides field supports a `sms` property and `from`, `to`, `content` field overrides. This allows you to send a message to a different recipient, from a different sender, or with a different content.

```javascript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  }
  overrides: {
    sms: {
      to: '+123012345678',
      from: 'Novu Team',
      content: 'This SMS message is from overrides'
    },
  },
});
```

## Using different SMS integration

In Novu integration store, multiple SMS channel type provider integrations can be active at the same time. But only one provider integration can be primary at a time. This primary integration will be used as a provider to deliver the SMS by default. If you want to use a different active provider integration then you can use the `integrationIdentifier` sms overrides field.

If there are 4 active SMS integrations with these identifiers:-

1. twilio-abcdef
2. twilio-ghijkl
3. firetext-abcdef
4. infobip-abcdef

Here, if `twilio-abcdef` is primary integration and you want to use `infobip-abcdef` with this trigger then you can use `integrationIdentifier` sms overrides field as below:-

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        sms: {
          integrationIdentifier: "infobip-abcdef"
        },
      },
    });
    ```
  </Tab>
</Tabs>

<Info> Integration identifier is similar to Provider identifier but it is different than Provider Id. It is unique for each integration. You can find the `integrationIdentifier` in the integration store page.  </Info>

## Common errors

Common errors and reason for these errors while sending sms messages using Novu.

1. Subscriber does not have a configured channel.
   * if the `from` field is missing / null / undefined.

<Tip>
  <MissingProvider />
</Tip>


# Plivo
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/plivo

Learn how to use the Plivo provider to send sms notifications using Novu

You can use the [Plivo](https://www.plivo.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Plivo provider in the SMS channel, the first step is to create a Plivo account and add the Account SID and Auth token to the Plivo integration on the Novu platform.

# Finding the Account SID and Auth token

[Sign up](https://console.plivo.com/accounts/register/) or [Login](https://console.plivo.com/accounts/login/) to your Plivo account, and make a note of your Account SID and Auth token on the [Plivo console page](https://console.plivo.com/dashboard/).

# Creating a Plivo integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-plivo) page on Novu.
* Click the "Add a provider" button.
* Locate **Plivo** under the SMS section and click on the **Connect** button.
* Enter the `Account SID`.
* Enter the `Auth token`.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Plivo** in Novu.


# Sendchamp
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/sendchamp

Learn how to use the Sendchamp provider to send sms notifications using Novu

You can use the [Sendchamp](https://www.sendchamp.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Sendchamp provider in the SMS channel, the first step is to create a Sendchamp account and add your API key and Sender ID to the Sendchamp integration on the Novu platform.

## Retrieving your API Key

To find your Sendchamp API key:

* [Sign up](https://my.sendchamp.com/signup) or [Login](https://my.sendchamp.com/login) to your Sendchamp account.
* Click on the Avatar icon in the top right corner of the screen, and then click `API & Integrations` from the drop-down menu.

<Frame>
  <img />
</Frame>

Alternatively, you can access the API key from the Accounts menu.

* Scroll to the bottom of the sidebar (on the left) and click on `Accounts`.
* This will display a dropdown from which you can then click on `API keys & Webhooks` to view your API key.

<Frame>
  <img />
</Frame>

* On the API Keys page, copy the Public access key.

<Frame>
  <img />
</Frame>

## Get your Sender's ID

The Sender ID represents the sender of the message to your customers.

To get your Sender's ID:

* On the sidebar (on the menu on your left), click on `SMS`. This will display a dropdown. Click on `Sender ID` from the dropdown options.
* On the page that appears, you'll find a list of your Sender IDs

<Frame>
  <img />
</Frame>

If you have not created one yet:

* Click on the `Create Sender ID` button to request a Sender ID.
* Fill in the form.
* Click on `Add Sender ID` button.

<Frame>
  <img />
</Frame>

Once it is approved, you can use your Sender ID as the from field on the Novu platform.

## Create a Sendchamp integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-sendchamp) page on Novu.
* Click the "Add a provider" button.
* Locate **Sendchamp** under the SMS section and click on the **Connect** button.
* Enter your Sendchamp API Key.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Sendchamp** in Novu.


# SimpleTexting
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/simpletexting

Learn how to use the SimpleTexting provider to send sms notifications using Novu

You can use the [SimpleTexting](https://simpletexting.com/) SMS provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use SimpleTexting provider in the SMS channel, the first step is to create a SimpleTexting account and grab your `API KEY` in your settings.

# Creating a SimpleTexting integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-simpletexting) page on Novu.
* Click the "Add a provider" button.
* Locate **SimpleTexting** under the SMS section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `API Key`.
* Enter the `From` value.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **SimpleTexting** in Novu.


# SMS77
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/sms77

Learn how to use the SMS77 provider to send sms notifications using Novu

It is possible to use the [SMS77](https://www.sms77.io/en) provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the SMS77 provider in the SMS channel, the first step is to create an SMS77 account and add the personal API key to the SMS77 integration on the Novu platform.

# Find the API key

To find the SMS77 API key, log into the personal SMS77 account and navigate to the API Keys page by clicking on the 'Developer' tab present at the end of the sidebar. It is suggested to create a new API key for use with Novu. Copy the newly created API key.

# Creating an SMS77 integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-sms77) page on Novu.
* Click the "Add a provider" button.
* Locate **SMS77** under the SMS section and click on the **Connect** button.
* Enter the `API key`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Save** button.
* Now it is possible to send SMS notifications using **SMS77** in Novu.


# Telnyx
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/telnyx

Learn how to use the Telnyx provider to send sms notifications using Novu

You can use the [Telnyx](https://telnyx.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Telnyx provider in the SMS channel, you will need to create a Telnyx account and add your API key to the Telnyx integration on the Novu platform.

# Finding the API Key

To find your Telnyx API key:

* Log into your Telnyx account.
* Navigate to Account Setting.
* Then go to [Keys & Credentials](https://portal.telnyx.com/#/app/api-keys).
* You can copy the API key from there.
* Alternatively, you can create an API key by tapping on the Create API Key button.

Before copying it, make sure its status is showing active.

# Finding the Message Profile ID

To get your Message profile ID:

* Navigate to [Messaging](https://portal.telnyx.com/#/app/messaging) to find the profiles.
* Make sure you created a Telnyx Messaging Profile previously. Learn more [here](https://developers.telnyx.com/docs/v2/messaging/quickstarts/portal-setup).
* Go to the active Messaging Profile.
* Copy the profile ID.

# Making sure that the From address is valid

A valid from address must be a valid phone number in +E.164 format, a short code, or an alphanumeric sender ID associated with the sending messaging profile. Alphanumeric sender IDs must be between 1 and 11 characters long, and can only contain ASCII letters, numbers, and spaces. They must contain at least one letter.

# Creating a Telnyx integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations) page on the Novu.
* Click the "Add a provider" button.
* Locate Telnyx and click on the **Connect** button.
* Enter your Telnyx API Key.
* Fill in the Message profile ID field.
* Enter the Valid From address.
* Click on the `Disabled` button and `mark it as Active`.
* Click on the **Save** button.
* You should now be able to send notifications using Telnyx in Novu.


# Termii
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/termii

Learn how to use the Termii provider to send sms notifications using Novu

You can use the [Termii](https://termii.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Termii provider in the SMS channel, the first step is to create a Termii account and add your API key and Sender ID to the Termii integration on the Novu platform.

## Retrieving your API Key

To find your Termii API key:

* [Sign up](https://accounts.termii.com/#/register) or [Login](https://accounts.termii.com/#/login) to your Termii account.
* Navigate to your [dashboard](https://accounts.termii.com/#/).
* Then scroll to the bottom of the page to find your API key.

<Frame>
  <img />
</Frame>

Alternatively, you can find the API key on the Settings page.

* Scroll to the bottom of the sidebar (on the left) and click on settings.
* This will display a dropdown from which you can then click on `API Token` to view your API key.

<Frame>
  <img />
</Frame>

## Getting your Sender's ID

Sender IDs allow you to brand your messages as you send them to your customers.

To get your Sender's ID:

* On the sidebar (on the menu on your left), click on `Rental`. This will display a dropdown. Click on `SMS Sender IDs` from the dropdown options.
* On the page that appears, you'll find a list of your Sender IDs

<Frame>
  <img />
</Frame>

If you have not created one yet:

* Click on the `Make a new request` button to request a Sender ID.
* Fill in the form
* Click on `Save`

<Frame>
  <img />
</Frame>

## Creating a Termii integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations) page on Novu.
* Click the "Add a provider" button.
* Locate **Termii** under the SMS section and click on the **Connect** button.
* Enter your Termii API Key.
* Fill in the `From` field.
* Click on the Disabled button and mark it as Active.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Termii** in Novu.


# Twilio
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/twilio

Learn how to use the Twilio provider to send sms notifications using Novu

You can utilize the [Twilio](https://www.twilio.com/) API to communicate with your customers using SMS messaging. Let’s look at how you can do that:

# Setting up Twilio

1. First, go to [Twilio](https://www.twilio.com/) and create an account, probably starting with their free trial.
2. You’ll be asked to verify your email and your phone number. Get them verified.
3. Once you’re done with that, you’ll get an option to ‘get a Twilio phone number’ from your Twilio console.
4. Click on it to get your Twilio phone number.

When first using Twilio there should be an option to get a Twilio phone number in the main console. Otherwise, you may have to [Buy](https://console.twilio.com/us1/develop/phone-numbers/manage/search?frameUrl=%2Fconsole%2Fphone-numbers%2Fsearch%3Fx-target-region%3Dus1\&currentFrameUrl=%2Fconsole%2Fphone-numbers%2Fsearch%3FisoCountry%3DUS%26searchTerm%3D%26searchFilter%3Dleft%26searchType%3Dnumber%26x-target-region%3Dus1%26__override_layout__%3Dembed%26bifrost%3Dtrue) a number from that link to begin using it. Assuming this is the first run though, utilize the free number given to us.

Simply follow one of their many [Tutorials](https://www.twilio.com/docs/usage/requests-to-twilio) within their docs to understand every part of the process.

Irrespective of the language you use, the process is the same:

* Load the Account SID and Auth token into the code, using some sort of safe environment such as .env variables. Nobody should have access to this but you.
* Create a client object from Twilio that take the SID and Token as variables then create a message with the client.
* A message is an object that has three things:
  * that free number from earlier,
  * the number you would like to send to, and
  * a body message that you want to send through SMS.

# Creating a Twilio integration with Novu

Creating a Twilio integration with Novu is quite simple. Just follow these steps:

* Visit the [Integrations Store](https://web.novu.co/integrations) on Novu.
* Click the "Add a provider" button.
* Locate **Twilio** and click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.
* Go to your [Console](https://console.twilio.com/) on Twilio and access the Account Info section at the bottom of the page
* Enter your `Account SID`, `Auth Token` and `Twilio Phone Number`.
* Click on the **Save** button.
* You should now be able to send SMS notifications using **Twilio** in Novu.

## Sending an WhatsApp message with Twillio

To send a WhatsApps message with Twillio integration prefix the phone number of the subscriber with `whatsapp:` as shown below.

```ts theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
  {
    to: {
      subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
      phone: 'whatsapp:555-4242'
    },
  }
);
```

Read more about [sending a Message with the Twilio API for WhatsApp](https://www.twilio.com/docs/whatsapp/tutorial).


# Add a new provider
Source: https://v0.x-docs.novu.co/community/add-a-new-provider

Steps to add a new provider to Novu

Interested in expanding Novu's capabilities? By contributing to our growing ecosystem, you can enhance Novu's reach and impact.

## How to add a new provider?

Novu currently supports five channels `in_app`, `push`, `email`, `chat` and `sms`.

For `in_app` we support only our own provider, so new providers cannot be added to this channel. For the other four channels, we support the integration of external providers. This guide will help in adding new providers for any of these 4 channels.

In this guide, we are adding a new provider for the email channel, but all of the mentioned steps are similar for other channels as well.

## Description

Providers allow us to handle message delivery over multiple channels.

We have multiple providers for each channel (SMS, Email, Push and Chat). To get started with adding a new provider let's look at setting up our repository.

## Requirements

* Node.js version v20.8.1
* MongoDB
* Redis
* **(Optional)** pnpm - Needed if you want to install new packages
* **(Optional)** localstack (required only in S3 related modules)

Need help installing the requirements? [Read more here](/community/run-in-local-machine)

<Note> We have used pnpm package manager in this guide. You can use npm as well. </Note>

## Initialization

Fork the novu repository and clone it in your local machine.

```shell theme={null}
git clone https://github.com/<'YOUR_GITHUB_USER_NAME'>/novu.git
```

To set up the repository, run the initial setup command:

```shell theme={null}
pnpm run setup:project
```

At the root of the project build the `node` package to get started.

```shell theme={null}
cd packages/node && pnpm run build
```

## Generate provider

After the project is initialized, a new provider can be generated using the below command.

```shell theme={null}
pnpm run generate:provider
```

<Note> Use the above command at the root of the project. </Note>

Choose the provider type.

```shell theme={null}

? What type
❯ EMAIL
  SMS
  PUSH
  CHAT
```

Use `up` and `down` arrow to switch `channel` type and press `enter` to select.

For this example, we will be selecting `EMAIL` as our provider type. The name for our provider will be `example-provider`.

```
? Write the provider name`kebab-cased` (e.g. proton-mail, outlook365, yahoo-mail): example-provider
```

Make sure your selected name is not conflicting with our existing provider's name. Boilerplate files for this new `example-provider` is generated in your local machine project.

> In above example, we have given our provider name as example-provider for simplicity. If provider you want to add have name as twilio, don't use twilio-provider as name, instead use twilio only. If one provider supports multiple channels like infobip supports both sms and email channels, use infobip-email or infobip-sms to differentiate these providers.

Once our `example-provider` is generated we will need to begin working from within `packages/providers/src/lib/example-provider` directory. Make sure to write the test for this new provider.

```ts packages/providers/src/lib/example-provider/example-provider.provider.ts theme={null}
import {
  ChannelTypeEnum,
  ISendMessageSuccessResponse,
  IEmailOptions,
  IEmailProvider,
} from '@novu/stateless';

export class ExampleProviderEmailProvider implements IEmailProvider {
  id = 'example-provider'
  channelType = ChannelTypeEnum.EMAIL as ChannelTypeEnum.EMAIL;

  constructor(
    private config: {
      apiKey: string;
    }
  ) {}

  async sendMessage(options: IEmailOptions): Promise<ISendMessageSuccessResponse> {
    return {
      id: 'id_returned_by_provider',
      date: 'current_time'
  }
}
```

### Template test case for `example-provider`.

```ts packages/providers/src/lib/example-provider/example-provider.provider.sepc.ts theme={null}
import { ExampleProviderEmailProvider } from './example-provider.provider';

test('should trigger example-provider library correctly', async () => {});
```

<Info> Add the provider's SDK as a dependency in the provider's package.json file. Run `pnpm run setup:project` to build all dependencies again. Use this new sdk method to complete the provider's `sendMessage` function. Check the **[reference links for adding new providers](#reference-for-adding-new-providers)** section for each channel's provider example. </Info>

### Add provider logos

In order to present this new provider in the `integration store` we need logos in dark and light mode. Add dark color svg logo in  `apps/web/public/static/images/providers/dark/sqaure` directory and light color svg logo in  `apps/web/public/static/images/providers/light/sqaure` directory.

Use the provider name as the file name. The sample name for our above-added provider is `example-provider.svg`.

## Add config items to the list

In order to build the UI integration store, we need to provide it list of all provider integrations. This part is made up of two parts:

* Create credentials config
* Add ProviderId Enum
* Add provider configuration to the providers list

### 1. Create credentials config

Every provider requires some credentials to create an instance. Novu will add these credentials fields in the integration store provider's form so that users can use their credentials to connect to their preferred provider to use for that channel notification. For example, in the above added `example-provider`, we have only one credential `ApiKey`. We will need to add a config object for `example-provider` with all existing provider's configs like below.

```tsx libs/shared/src/consts/providers/credentials/provider-credentials.ts theme={null}
export const exampleProviderConfig: IConfigCredentials[] = [
  {
    key: CredentialsKeyEnum.ApiKey,
    displayName: "API Key",
    description: "This is API key for example provider",
    type: "text",
    required: true,
  },
  ...mailConfigBase,
];
```

1. Here the `key` is of type `CredentialsKeyEnum`.

> If a new key is added, add this key at these 3 places:-
>
> * In `CredentialsKeyEnum` at file `libs/shared/src/consts/providers/provider.enum.ts`
> * In `CredentialsDto` at file `apps/api/src/app/integrations/dtos/credentials.dto.ts`
> * In `credentials` field of `integrationSchema` at file `libs/dal/src/repositories/integration/integration.schema.ts`

2. `displayName` is a human-friendly easy to understand name which will be shown in the provider integration form for this credential.
3. `description` is a field that can be used to share more information about the credential.
4. `type` here means text field type. this can be a string for text, text for text-area, or a switch for the toggle.
5. `required` is of boolean type.
6. `mailConfigBase` is an object having default credentials required by any `email` provider. Make sure not to add duplicate providers which are already there in `mailConfigBase`. In the case of another channel provider, we will use that channel config base in place of `mailConfigBase`.

> A credential can be made secret by adding in ./secure-credentials.ts file.

### 2. Add ProviderId Enum

Add this new provider id in the respective channel provider id enum in file `libs/shared/src/consts/providers/provider.enum.ts`. As our `example-provider` is of email type, add this in `EmailProviderIdEnum` with all existing providers like below

```tsx libs/shared/src/consts/providers/provider.enum.ts theme={null}
export enum EmailProviderIdEnum {
  ExampleProvider = "example-provider",
}
```

### 3. Add provider to providers list

Now we need to add the provider data to the list located at `libs/shared/src/consts/providers/channels/email.ts`. Note that the `id` is the provider's name, `displayName` is the provider's name in Pascal's case, `credentials` are the ones we created in the previous step, `logoFileName` should be as it was on the adding logo step (with the format type included).

```tsx libs/shared/src/consts/providers/channels/email.ts theme={null}
{
  id: 'example-provider',
  displayName: 'Example Provider',
  channel: ChannelTypeEnum.EMAIL,
  credentials: exampleProviderConfig,
  // Use valid documentation link
  docReference: 'https://docs.example-provider.com/',
  logoFileName: { light: 'example-provider.svg', dark: 'example-provider.svg' }
}
```

## Add provider handler in the API

### 1. Adding the provider dependency in the application-generic package

In the previous step, we created a standalone provider package that will be published to NPM. However currently in our development environment, it is not yet published. In order to use it locally please go to the `package.json` located in `packages/application-generic/package.json` and add it manually to the dependencies list: `"@novu/<NEW_PROVIDER_NAME>": "^<VERSION>"`

> Please note that the provider name and version can be found from the provider package.json you created earlier.

After adding the dependency run `pnpm run setup:project` from the root of the mono repo. so, it can create the required symlinks for the newly created package.

### 2. Create a provider handler

In order to map internally the different providers’ credentials, we need to add a provider handler at the respective channel handlers located. For Email, it can be found at `apps/packages/application-generic/src/factories/mail/handlers`. Other channel handlers can also be found here.

Create a new file `example-provider.handler.ts` here with the following code

```tsx packages/application-generic/src/factories/mail/handlers/example-provider.handler.ts theme={null}
import { ChannelTypeEnum } from "@novu/shared";
import { ExampleProviderEmailProvider } from "@novu/example-provider";
import { BaseHandler } from "./base.handler";

export class ExampleProviderHandler extends BaseHandler {
  constructor() {
    super("example-provider", ChannelTypeEnum.EMAIL);
  }

  buildProvider(credentials, from: string) {
    const config: { apiKey: string } = { apiKey: credentials.apiKey };

    this.provider = new ExampleProviderEmailProvider(config);
  }
}
```

Add this line given below to export this handler

```tsx packages/application-generic/src/factories/mail/handlers/index.ts theme={null}
export * from "./example-provider.handler";
```

### 3. Add handler to factory

The last step is to initialize the handler in the factory located in `packages/application-generic/src/factories/mail/mail.factory.ts`

```tsx packages/application-generic/src/factories/mail/mail.factory.ts theme={null}
import { ExampleProviderHandler } from "./handlers";

export class MailFactory {
  handlers: IMailHandler[] = [new ExampleProviderHandler()];
}
```

### Final Steps

Now, build the project again using this command

```shell theme={null}
pnpm run setup:project
```

Run novu in your local machine. Read [here](/community/run-in-local-machine) to learn on how to run novu on a local machine and test this new provider.

Run the below command in the root of the project to run the providers test

```shell theme={null}
pnpm run test:providers
```

If everything is working fine without any error, commit your local branch changes, push this branch and create a new pull request to our main repo.

Hurray 🎉! You have successfully added a new provider in Novu!

<Info>️ In this guide, we have used only one credential `apiKey` for our `example-provider`. This is for reference purposes only. A provider can have more than one credential as per its `SDK` requirements. At each step, you will need to add all credentials carefully. Check providers referenced below for more information. </Info>

### Reference for Adding New Providers

* [SendGrid Email Provider](https://github.com/novuhq/novu/blob/next/providers/sendgrid/src/lib/sendgrid.provider.ts)
* [Twilio SMS Provider](https://github.com/novuhq/novu/blob/next/providers/twilio/src/lib/twilio.provider.ts)
* [FCM Push Provider](https://github.com/novuhq/novu/blob/next/providers/fcm/src/lib/fcm.provider.ts)
* [Slack Chat Provider](https://github.com/novuhq/novu/blob/next/providers/slack/src/lib/slack.provider.ts)
* [Resend - How to add an Email Provider to Novu](https://dev.to/novu/resend-how-to-add-an-email-api-provider-to-novu-49cd)


# Changelog
Source: https://v0.x-docs.novu.co/community/changelog

See the most recent changes and learn about how to shape Novu's future

<Card title="Novu's Changelog" icon="map" href="https://github.com/novuhq/novu/releases/">
  Learn about what's changed, new features, bug fixes, and see Novu's history across versions.
</Card>

Using the changelog, you can:

* Keep an eye on the latest updates,
* Learn more about the newly added features and improvements, and
* Stay informed about bug fixes and enhancement

## Getting involved:

Community is at the heart of everything we do at Novu. To get more involved with the community, you can:

* **Fork and Contribute** to our open issues as well as suggest new ideas at our [github repository](https://github.com/novuhq/novu)
* **Join our community** to ask questions, engage with other users and share ideas. Here's the [joining link.](https://discord.gg/novu?ref=docs-join-our-community)
* **Participate in our office hours** to learn more and connect with our core team. Join us [here.](https://www.youtube.com/@novuhq/streams)

<Tip>
  Remember, we're not building just another product, but a community of passionate developers who shape its evolution. Our changelog isn't just a list of updates but a reflection of our journey together. Your voice matters, and your ideas and feedback are what fuel our progress and shape our future. So, join us in this adventure, and – Let's build something amazing, one feature at a time!
</Tip>


# Novu Community Code of conduct
Source: https://v0.x-docs.novu.co/community/code-of-conduct

The set of rules and guidelines that govern interaction among community members

As a community-driven company, Novu is committed to creating an inclusive and welcoming environment for all members, regardless of factors such as age, body size, disability, ethnicity, gender identity, experience level, education, socio-economic status, nationality, personal appearance, race, religion, or sexual orientation.

However, diverse communities may face challenges, such as potential misunderstandings and miscommunications. To ensure respectful interactions, free from behaviour that may create an unsafe environment, we have established this Code of Conduct.

These guidelines do not cover every possible scenario comprehensively but serve as a guiding light towards courteous interactions among community members, aligning with the overarching principle of avoiding unprofessional behaviour. This Code of Conduct applies to all events and participants, aiming to maintain a welcoming and healthy environment for our community.

Traits of a Novu community member include:

### Being considerate and using appropriate channels

Contributions of every kind have far-ranging consequences. Just as your work depends on the work of others, decisions you make surrounding your contributions to the Novu community will affect your fellow community members. Use appropriate channels for what you’re about to say and refrain from tagging a role that sends out a lot of pings. You are strongly encouraged to take those consequences into account while making decisions.

### Adhering to these standards

It's crucial to keep in mind that our community members are from all kinds of backgrounds, so the members are expected to:

* Demonstrate empathy and kindness toward other people
* Be respectful of differing opinions, viewpoints, and experiences
* Give and accept constructive feedback gracefully
* Accept responsibility and apologise to those affected by mistakes, and learn from such experiences
* Focus on what is best not just for us as individuals, but for the overall community!

### Patience

Our community thrives on the generosity of volunteered time. Questions, contributions, and support requests may embark on a time-travelling journey before finding their destination. Repeated "bumps" or persistent "reminders" don’t display patience and are looked down upon. Lastly, it is a bad practice to ask general questions to a specific person (in direct messages for example). Try to ask in public as much as you can, and patiently wait for the response

### Inclusivity, kindness and respectfulness

Please be courteous and respectful to fellow members. Avoid offensive comments related to age, body size, disability, ethnicity, gender identity, experience level, education, socio-economic status, nationality, personal appearance, race, religion, or sexual orientation.

Strictly prohibited are sexualized imagery, violence, intimidation, stalking, disruptions, sharing personal information without explicit permission, unwanted physical contact, and unwelcome sexual attention.

Use inclusive language respecting our community's diversity.

Avoid assumptions about others' backgrounds. Maintain a positive and professional demeanour, refraining from threatening or inappropriate behaviour.

**We have zero tolerance for discrimination**. Any form of discrimination, including harassment, will lead to immediate consequences, potentially expulsion.

### Inquisitive

***The only stupid question is the one that does not get asked***.

We encourage our users to ask early and ask often. Rather than asking whether you can ask a question (the answer is always yes!), instead, simply ask your question. You are encouraged to provide as many specifics as possible.

Code snippets in the form of images are bad practice. Instead, use text formatted as code (using backticks) on Discord or simply send a gist. Refrain from pasting multiple lines of code directly into the chat channels - instead use [gist.github.com](http://gist.github.com/) or another paste site to provide code snippets.

### Helpful

Novu welcomes users of all skill levels. We were all beginners once, and a supportive environment is essential for the community to thrive. While it can be repetitive to answer the same questions, members are expected to be courteous and helpful to everyone.

Avoid sarcastic responses and prioritize useful information. Everyone should read the provided documentation. We're here to answer questions, offer guidance, and suggest workflows, but not to do your job for you.

### Anti-harassment policy

Harassment includes (but is not limited to) all of the following behaviors:

* Offensive comments related to gender (including gender expression and identity), age, sexual orientation, disability, physical appearance, body size, race, and religion.
* Derogatory terminology including words commonly known to be slurs
* Posting sexualized images or imagery in public spaces
* Deliberate intimidation
* Stalking
* Posting others’ personal information without explicit permission
* Sustained disruption of talks or other events
* Inappropriate physical contact
* Unwelcome sexual attention

Immediate compliance is expected from participants asked to cease harassing behaviour. Sponsors must adhere to the anti-harassment policy, refraining from using sexualized images or creating a sexualized environment at events. Volunteer organizers, including meetup staff, should also avoid sexualized attire.

Continuing inappropriate behaviour after being asked to stop constitutes harassment, even if not explicitly mentioned in this policy. It is respectful to stop doing something when asked to do so, and all community members are expected to promptly comply with such requests.

### Reporting policy violations

Instances of abusive, harassing, or otherwise unacceptable behaviour may be reported to anyone with administrative power in the community (Admins or Moderators on Discord, members of the ‘DevRel’ role), or to the local organizers of an event or to [support@novu.co](mailto:support@novu.co). Meetup organizers are encouraged to prominently display points of contact for reporting unacceptable behaviour at local events.

If a participant engages in harassing behaviour, the meetup organizers may take any action they deem appropriate. These actions may include but are not limited to warning the offender, expelling the offender from the event, and barring the offender from future community events.

Organizers will be happy to help participants contact security or local law enforcement, provide escorts to an alternate location, or otherwise assist those experiencing harassment to feel safe during the meetup. We value the safety and well-being of our community members and want everyone to feel welcome at our events, both online and offline.

We expect all participants, organizers, speakers, and attendees to follow these policies at all of our event venues and event-related social events.

### Enforcement Guidelines

Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:

1. **Correction**

* `Community Impact`: Use of inappropriate language or other behaviour deemed unprofessional or unwelcome in the community.
* `Consequence`: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behaviour was inappropriate. A public apology may be requested.

2. **Warning**

* `Community Impact`: A violation through a single incident or series of actions.
* `Consequence`: A warning with consequences for continued behaviour. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.

3. **Temporary Ban**

* `Community Impact`: A serious violation of community standards, including sustained inappropriate behaviour.
* `Consequence`: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.

4. **Permanent Ban**

* `Community Impact`: Demonstrating a pattern of violation of community standards, including sustained inappropriate behaviour, harassment of an individual, or aggression toward or disparagement of classes of individuals.
* `Consequence`: A permanent ban from any sort of public interaction within the community.

The Novu Community Code of Conduct is licensed under the Creative Commons Attribution-Share Alike 3.0 license.

Our Code of Conduct was adapted from Codes of Conduct of other open-source projects, including:

* **Contributor Covenant**
* **Elastic**
* **The Fedora Project**
* **OpenStack**
* **Ansible**
* **Puppet Labs**
* **Ubuntu**

Community Impact Guidelines were inspired by Mozilla's code of conduct enforcement ladder.

For answers to common questions about this code of conduct, see the FAQ at [https://www.contributor-covenant.org/faq](https://www.contributor-covenant.org/faq).

Translations are available at [https://www.contributor-covenant.org/translations](https://www.contributor-covenant.org/translations).


# Feature Flags
Source: https://v0.x-docs.novu.co/community/feature-flags

Learn how to enable/disable specific features in Novu

Feature flags allow to turn certain functionality on and off based on configuration. In this way, users can preview beta features in their deployments.

To enable the specific feature, you need to pass an environment variable to all services:

<Note>
  Feature flag environment variable accepts boolean values: `true` or `false`.
</Note>

* `IS_MULTI_PROVIDER_CONFIGURATION_ENABLED` adds ability to connect multiple providers per channel and make them active. It also shows redesigned integrations store page.

<Frame>
  <img />
</Frame>

* `IS_MULTI_TENANCY_ENABLED` adds ability to manage tenants from dashboard.

<Frame>
  <img />
</Frame>

* `IS_TEMPLATE_STORE_ENABLED` enables template store which contains pre-made workflows for common use cases (like **Password Reset** workflow etc).

<Frame>
  <img />
</Frame>


# Get involved with the Novu Community
Source: https://v0.x-docs.novu.co/community/get-involved

Your guide for engaging with the Novu Community

## Our Community

At Novu, we're a vibrant, open-source community driven by passion, collaboration, and a shared love for pushing boundaries. We believe in the power of community-driven development, where every voice matters and every contribution counts. As such, contributions are at the heart of how we evolve and progress forward.

## Join the conversation

* Read our [code of conduct](/community/code-of-conduct)
* Say “Hi!” in our [Discord Server](https://discord.gg/novu?ref=docs-community-introduction)
* Explore our [open issues](https://github.com/novuhq/novu/issues)
* Subscribe to our newsletter [to stay in the know](https://novu.co/novu-community-2-0/?utm_campaign=docs-comm2-get-involved)

## Getting help

Our fellow community members are always ready to help you get past a blocker. However, you can take a few things into consideration to help them help you:

* Share as many details as you can share. It will help us in debugging the issue.
* If there is any bug, please share steps to reproduce that bug.
* If there is any issue in running Novu on a local machine, please share system details like operating system, RAM size, npm version and node version.
* If there is any issue in our backend SDKs, please mention the SDK version and relevant details.
* If looking for self-hosting support, please share `Novu Version` and remote server details. Our latest version is `0.24.0`. Please be patient with self-hosting help. We are a small team and we will try our best to help you.

<Tip>Intercome is suitable if you're using Novu cloud or. Kindly use Discord or Github for community self-hosting questions.</Tip>

## Contributing

All community members are of one of the following four types:

1. Open source users
2. Active member
3. Power member
4. Novu Ambassador

### Become an active community member

* Everyone who joins our community becomes an open-source user automatically.
* You can become an active community member by:
  * Submitting >2 PRs
  * Opening >2 issues
  * Sending >5 messages on Github
  * Commenting >3 times on Github
* Active community members are one step closer to becoming Power community members and then an active moderator.

### Become a power community member

* All active community members are eligible to become a power community member and can become so by having at least one of the following:
  * Submitting 3 PRs
  * Opening 3 Issues
  * Sending 10 Discord messages
  * Commenting >10 times on Github
* Power community members are just one step away from becoming a Novu ambassador.

### Become a Novu Ambassador

A Novu ambassador is a trusted power member of the community that can do the following:

* Love exploring and sharing their knowledge of any technology with other developers.
* Often write and speak about Novu.
* Possess strong Novu expertise and often help and support Novu users within the community.
* Socially influence developers with some knowledge of Novu.
* Consistently contribute to Novu OSS product.

We are launching the Novu Ambassador program soon with amazing perks. Stay tuned!

## Activities

Are you passionate about notifications like we are? There are many different—and easy—ways to get involved.

### Help in onboarding and answering questions.

* Welcome new users into the community
* Answer questions in the [community support channel](https://discord.com/channels/895029566685462578/1019663407915483176).
* Offer input and opinions about various solutions you have tried.

### Improve our documentation

* Check out our[GitHub repo](https://github.com/novuhq/docs)
* No documentation is perfect, and neither is ours
* Help us improve our docs by
  * Updating outdated examples
  * Correcting typos and language for clarity
  * Find and fix broken links, etc.

### Help with the SDKs

* Link to contributors guide([https://github.com/novuhq/novu/blob/next/CONTRIBUTING.md](https://github.com/novuhq/novu/blob/next/CONTRIBUTING.md))
* We have SDKs in various languages and frameworks, most written and maintained by community members.
* You can either become a maintainer there or help the existing maintainers by bringing the SDK up to speed with the latest features present in the core product.
  * We have backend SDKs in the following: [Node.js](https://github.com/novuhq/novu/tree/next/packages/node), [PHP](https://github.com/novuhq/novu-php), [.NET](https://github.com/novuhq/novu-dotnet), [Elixir](https://github.com/novuhq/novu-elixir), [Go](https://github.com/novuhq/go-novu), [Ruby](https://github.com/novuhq/novu-ruby), [Python](https://github.com/novuhq/novu-python) [Laravel](https://github.com/novuhq/novu-laravel), and [Kotlin](https://github.com/novuhq/novu-kotlin)
  * And client-side SDKs in the follwing: [Vue](https://github.com/novuhq/novu/tree/next/packages/notification-center-vue), [React](https://github.com/novuhq/novu/tree/next/packages/notification-center), [Angular](https://github.com/novuhq/novu/tree/next/packages/notification-center-angular), [Web Component](https://github.com/novuhq/novu/tree/next/packages/notification-center), [iframe embed](https://docs.novu.co/notification-center/client/iframe), and [Headless Javascript.](https://docs.novu.co/notification-center/client/headless/get-started)

### Create content

* Content writers program: Apply to become a content writer with us and get paid to write about use-cases highlighting how you solved a problem using Novu
* Write an article about what you built with Novu and share it with the community. We’ll give you a shout out!

### PRs, issues, and bug reports

* Check out our [contributors guide](https://github.com/novuhq/novu/blob/next/CONTRIBUTING.md)
* Once you’ve gone through our [development process](https://docs.novu.co/community/run-in-local-machine), you can contribute directly to open issues.
* Open a new issue if a relevant one isn’t already open.
* Also, you can create bug reports if you find a bug somewhere.
* Or a feature request if you find something that should be a feature but isn't.

<Info>
  At Novu, we believe that no contribution is small, and the only wrong question is the one that doesn’t get asked. So feel free to ask any question or raise that Pull Request. You’re always welcome here! 🤗
</Info>

### Participate in office hours

* We have frequent (replace with interval— twice weekly, weekly, etc.) and topic-specific office hours that offer the ability to engage in real-time with Novu staff and other community members
* In these sessions, offer input, opinions, examples, etc. to contribute!

We’re excited to have you on board and look forward to your valuable contributions!

Together, we’ll shape the future of Novu. 🫂


# MacOS/Linux
Source: https://v0.x-docs.novu.co/community/machine-setup

Learn how to configure your local machine to run Novu

## Terminal upgrade (Optional)

### Install ZSH

ZSH is a shell on steroids, it has multiple plugins and functionality that can save a lot of time.

To install zsh run in your command line:

```shell theme={null}
sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
```

<Note>
  If you previously haven’t installed git on the machine, a prompt to install
  git will show up. After installation, run the `sh` command from above again.
</Note>

<Note>
  Make sure you have a `~/.zshrc` exists, if not it might be an indicator that
  the installation failed for some reason.
</Note>

### ZSH auto-complete plugin

Add the autocomplete plugin for autocompleting previously typed commands in the shell. Follow the instructions [here](https://github.com/zsh-users/zsh-autosuggestions/blob/master/INSTALL.md#oh-my-zsh).

### Powerlevel10k (optional)

[Powerlevel10k](https://github.com/romkatv/powerlevel10k) is a theme for Zsh. It emphasizes [speed](https://github.com/romkatv/powerlevel10k#uncompromising-performance), [flexibility](https://github.com/romkatv/powerlevel10k#extremely-customizable), and [out-of-the-box experience](https://github.com/romkatv/powerlevel10k#configuration-wizard).

1. Clone the repository:

   `git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k`

2. Set `ZSH_THEME="powerlevel10k/powerlevel10k"` in `~/.zshrc`.

3. Restart your terminal and follow the onboarding wizard to configure it to your likings and preferences.

## Command Line Tools, Homebrew & Casks

Every developer utilizes *Command Line Tools*. A simple terminal command will allow you to download these. It will ask you to confirm after you have entered the command.

```shell theme={null}
xcode-select --install
```

### Homebrew & Casks

[Homebrew](https://brew.sh/), it’s the missing package manager for macOS, and quite powerful at that.

Copy and paste the following code into your terminal to install Homebrew.

```shell theme={null}
/bin/shell -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

It will ask you to enter 'Return' to confirm the installation.

<Note>
  After installation run, the `echo` and `eval` commands shown on screen to add
  brew to your shell executables
</Note>

## Setting up git

To set up git and create an access token for GitHub, suggested installing [GitHub Desktop](https://www.notion.so/Dev-Machine-Setup-98d274c80fa249b0b0be75b9a7a72acb?pvs=21) before.

## Helpful settings

Show hidden files in Finder: `cmd + shift + .` or in the terminal:

```shell theme={null}
defaults write com.apple.finder AppleShowAllFiles YES
```

## Development Environment

### Node & NVM

For installing node we suggest installing it using [NVM](https://github.com/nvm-sh/nvm) (Node Version Manager) for easily managing multiple node versions.

1. Install nvm on your machine.

```shell theme={null}
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | shell
```

<Note>
  Make sure that you have installed zsh previously, so NVM can automatically
  inject the executable to PATH in the .zshrc config file.
</Note>

2. After installing nvm and checking that it’s in the path by running `nvm --version` in your CLI. You can now install our node version:

<Note>
  After running the install script, if you get `nvm: command not found` or see
  no feedback from your terminal after you type `command -v nvm`, simply **close
  your current terminal, open a new terminal**, and try verifying again.
</Note>

3. Optional for M1 processors - Install Rosetta.

Rosetta enables a Mac with Apple silicon to use apps built for a Mac with an Intel processor.

```shell theme={null}
softwareupdate --install-rosetta
```

### PNPM

For package management, we use [PNPM](https://pnpm.io/) instead of npm or yarn to speed up our install times and space efficiency. To install pnpm globally run:

```shell theme={null}
npm install -g pnpm@8.9.0
```

### Docker

Follow the installation guide on [docker website](https://docs.docker.com/desktop/mac/install/) to install docker on your own machine. For ease of use, we suggest installing **Docker Desktop**.

### AWS CLI

Follow the instructions to install the AWS CLI so you can use it to create env later on, based on existing S3 buckets:

[Installing or updating the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

You should get something like this:

<Frame>
  <img alt="AWS CLI" />
</Frame>

If needed, see:

[Resolve "Unable to locate credentials" error in Amazon S3](https://aws.amazon.com/premiumsupport/knowledge-center/s3-locate-credentials-error/)

### Run LocalStack

This is needed only when you upload files (for example - an image) in the admin panel from your local environment.

LocalStack emulates cloud service that runs in a single container on your computer. So you can run your AWS applications on your local machine without connecting to the remote cloud provider.

1. Build a container and run it:

```shell theme={null}
docker run --rm -it -p 4566:4566 -p 4571:4571 localstack/localstack
```

2. Create local S3 buckets needed for the app:

   In **local** environment:

   ```shell theme={null}
   aws --endpoint-url=http://localhost:4566 s3 mb s3://novu-local
   ```

   In **test** environment:

   ```shell theme={null}
   aws --endpoint-url=http://localhost:4566 s3 mb s3://novu-test
   ```

3. Update cors:

   ```json theme={null}
   aws --endpoint-url=http://localhost:4566 s3api put-bucket-cors --bucket novu-local --cors-configuration file://cors.json
   ```

   ```json cors.json theme={null}
   {
     "CORSRules": [
       {
         "AllowedOrigins": ["*"],
         "AllowedHeaders": ["*"],
         "AllowedMethods": ["GET", "PUT", "POST", "DELETE"],
         "MaxAgeSeconds": 3000,
         "ExposeHeaders": ["x-amz-server-side-encryption"]
       }
     ]
   }
   ```

### MongoDB

After installing brew you can easily install the MongoDB community edition.

1. Tap the [MongoDB Homebrew Tap](https://github.com/mongodb/homebrew-brew) to download the official Homebrew formula for MongoDB and the Database Tools, by running the following command in your macOS Terminal:

```shell theme={null}
brew tap mongodb/brew
```

2. To install MongoDB, run the following command in your macOS Terminal application

   1. You might need to update the Command Line Tools to be compatible with Xcode - see

   [Sign in with your Apple ID](https://developer.apple.com/download/all/?q=Xcode)

```shell theme={null}
brew install mongodb-community@5.0
```

3. Run the service in the background and start automatically after restart.

```shell theme={null}
brew services start mongodb/brew/mongodb-community@5.0
```

### Redis

After installing homebrew run the redis installation

```shell theme={null}
brew install redis
```

After installation run the service to start on system start as well.

```shell theme={null}
brew services restart redis
```

### Local dev domain (Optional)

This will allow you to use [local.novu.co](http://local.novu.co) instead of [localhost](http://localhost) when accessing the service on your machine.

Open the `/etc/hosts` file:

```shell theme={null}
sudo nano /etc/hosts
```

And add the [local.novu.co](http://local.novu.co) domain

```shell theme={null}
127.0.0.1       local.novu.co
```

### Code Editor

Feel free to install your favorite code editor. We supply licenses for [WebStorm](https://www.notion.so/WebStorm-7570ab1037bf494d88d0f9b544ae3b79?pvs=21), or you can [Visual Studio Code](https://code.visualstudio.com/download) if you prefer it.

### Productivity tools

* GitHub Desktop (Optional)

GitHub Desktop simplifies the development workflow and interaction with Git. [Download](https://desktop.github.com/) the client from their website.

* Clean your Dock bar (Optional)

For better productivity and wellness, we suggest removing the not-used apps from LaunchBar. Don’t worry if you will remove most apps from there. You can always use the spotlight to open the apps you need. Clean workspace === Happy life :)
Right Click on the app icon > Options > Remove from Dock

<Frame>
  <img alt="Dock" />
</Frame>


# Monorepo Structure
Source: https://v0.x-docs.novu.co/community/monorepo-structure

Learn the components of Novu's monorepo

In this guide, we will explore the Novu mono-repo structure and high-level structure of the different libraries and services we use.

## Setting up the monorepo

Novu uses [PNPM](https://pnpm.js.org/) as its package manager, and [NX](https://nx.dev/) as its build CLI tool. PNPM reduces the installation time and generates symlinks for all the internal packages we use.

To initialize the monorepo, run the following command from the root of the project:

```bash theme={null}
npm run setup:project
```

This will:

* run `pnpm install`, which will download all the needed dependencies and create symlinks for packages.
* copy the `.env.example` file to the `.env` file for the API service.
* execute the `npm run build` command to build all the dependency trees locally.

For additional information on running Novu locally, visit the [run locally](https://docs.novu.co/community/run-in-local-machine) guide.

## Apps

The `apps` folder contains high-level applications and APIs. The app's outputs usually contain deployable units that a user can interact with either as an API or as a web/cli application.

<Steps>
  <Step title="API">
    The API package is our main service for handling backend logic. It handles anything from authentication, authorization, workflow management, triggering events, etc... This is where the Novu business logic is handled.
  </Step>

  <Step title="WS aka Web Socket">
    This is the WebSocket NestJs server which connects to the widget and provides real-time updates about new notifications to the widget consumer.
  </Step>

  <Step title="Web aka Admin Panel">
    This is the Novu admin panel which is used to visually communicate with the API. You can configure workflows, manage content, enable or disable notifications, visually track the notification activity feed, etc...

    The `WEB` project is a create-react-app built, well, with React. 😄
  </Step>

  <Step title="Widget">
    This is the client of our embeddable notification center widget. It is consumed mainly with the embed script in an Iframe. We can access it on port 4500 to interact with it directly.
  </Step>

  <Step title="Worker">
    This is our service for managing and handling workers.
  </Step>
</Steps>

## Libs

<Steps>
  <Step title="@novu/dal">
    The `DAL` is our Data-Access-Layer. This is our connection to the DB service and wraps MongoDB and mongoose. When another service or API needs to consume the DB, it does not do that directly but uses the DAL as an interface. Importing `mongoose` directly outside the `dal` is not allowed.
  </Step>

  <Step title="@novu/testing">
    This is a utility library that contains testing helpers. The testing helpers can generate test sessions and other functionality for e2e and unit-tests between our services.
  </Step>

  <Step title="@novu/shared">
    The shared library contains reusable code and typescript interfaces between client and server packages. Code in the shared library should not contain any sensitive content because it can be accessed and downloaded by the web or other clients.
  </Step>

  <Step title="@novu/embed">
    This is the connector between our client's web app and the widget project. It’s a small shim script that generates an iframe and attaches it to a client-specified div to host the notification widget.

    If you are familiar with the Google Analytics embedded snippet or intercom-like embeddings, it uses the same mechanics.
  </Step>
</Steps>

## Packages (on npm)

<Steps>
  <Step title="@novu/node">
    A Standalone Node.js wrapper around the Novu API. Exists to provide type-safe and easier access to the different API endpoints Novu exposes (Triggers, subscribers, etc…).
  </Step>

  <Step title="@novu/nest">
    A Nest.js wrapper around the `@novu/node` package was created by the community to easily interact with the core library from a nest project. Also released on NPM as a package.
  </Step>

  <Step title="@novu/notification-center">
    React component library that contains widget bell with the notification center. Can get override of components like ‘bell icon’, and ‘notification center’.
  </Step>
</Steps>

## Providers

These are the API wrappers created by the community to wrap communication providers in the following channels:

Novu provides a single API to manage providers across multiple channels with a simple-to-use interface.

### 💌 Email

* [Sendgrid](https://github.com/novuhq/novu/tree/main/providers/sendgrid)
* [Netcore](https://github.com/novuhq/novu/tree/main/providers/netcore)
* [Mailgun](https://github.com/novuhq/novu/tree/main/providers/mailgun)
* [SES](https://github.com/novuhq/novu/tree/main/providers/ses)
* [Postmark](https://github.com/novuhq/novu/tree/main/providers/postmark)
* [Custom SMTP](https://github.com/novuhq/novu/tree/main/providers/nodemailer)
* [Mailjet](https://github.com/novuhq/novu/tree/main/providers/mailjet)
* [Mandrill](https://github.com/novuhq/novu/tree/main/providers/mandrill)
* [SendinBlue](https://github.com/novuhq/novu/tree/main/providers/sendinblue)

### 📞 SMS

* [Twilio](https://github.com/novuhq/novu/tree/main/providers/twilio)
* [Plivo](https://github.com/novuhq/novu/tree/main/providers/plivo)
* [SNS](https://github.com/novuhq/novu/tree/main/providers/sns)
* [Nexmo - Vonage](https://github.com/novuhq/novu/tree/main/providers/nexmo)
* [Sms77](https://github.com/novuhq/novu/tree/main/providers/sms77)
* [Telnyx](https://github.com/novuhq/novu/tree/main/providers/telnyx)
* [Termii](https://github.com/novuhq/novu/tree/main/providers/termii)
* [Gupshup](https://github.com/novuhq/novu/tree/main/providers/gupshup)

### 📱 Push

* [FCM](https://github.com/novuhq/novu/tree/main/providers/fcm)
* [Expo](https://github.com/novuhq/novu/tree/main/providers/expo)
* [SNS](https://github.com/novuhq/novu/tree/main/providers/sns)

### 👇 Chat

* [Slack](https://github.com/novuhq/novu/tree/main/providers/slack)
* [Discord](https://github.com/novuhq/novu/tree/main/providers/discord)

### 📱 In-App

* [Novu](https://docs.novu.co/notification-center/getting-started)


# Roadmap
Source: https://v0.x-docs.novu.co/community/roadmap

Learn about our roadmap

<Card title="Novu's Roadmap" icon="map" href="https://roadmap.novu.co/roadmap">
  Learn about ongoing developments, upcoming plans, and items in our backlog..
</Card>

Your involvement in shaping the future of our notification infrastructure solution is highly encouraged.

## Get involved

**Submit Ideas:** If you have a new feature idea or an enhancement suggestion, don't hesitate to submit it through our [roadmap page](https://roadmap.novu.co/roadmap). Your creativity fuels our innovation!

**Upvote and Comment:** Review the existing feature requests and upvote the ones that resonate with you. Feel free to provide additional insights or use-cases through comments.

**Contribute:** If you're a developer, you can actively contribute to the development of the features in progress or even the backlog ones. [Join our community of contributors](https://discord.gg/novu?ref=docs-contribute) and help us bring these enhancements to life.

<Tip>Remember, this roadmap is a living document that evolves based on your input and the direction the community decides to take. Your voice matters, and we're excited to work together in building a robust notification infrastructure solution that meets everyone's needs.</Tip>


# Run Novu in local machine
Source: https://v0.x-docs.novu.co/community/run-in-local-machine

Prerequisites and steps to run Novu in local machine. Learn how to set up Novu on your local environment for testing and development.

[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/novuhq/novu)

### Requirements

* Node.js version v20.8.1
* MongoDB
* Redis
* **(Optional)** pnpm - Needed if you want to install new packages
* **(Optional)** localstack (required only in S3 related modules)

Need help installing the requirements? Read more [here](/community/machine-setup).

<Note>We recommend having at least 8GB of RAM to run Novu on a local machine as Novu has multiple services running together with external services like redis, mongodb etc.</Note>

<iframe />

### Setup the project

After installing the required services on your machine, you can clone and set up
your forked version of the project:

1. Clone the repository

<Tabs>
  <Tab title="Novu Org">
    ```shell theme={null}
    git clone https://github.com/novuhq/novu.git
    ```
  </Tab>

  <Tab title="Forked Repo">
    ```shell theme={null}
    git clone https://github.com/{YOUR_GITHUB_USER_NAME}/novu.git
    ```
  </Tab>
</Tabs>

2. Install all dependencies

```shell theme={null}
cd novu && npm run setup:project
```

3. Run the project

```shell theme={null}
npm run start
```

The `npm run start` will start the Jarvis CLI tool which allows you to run the whole project with ease. If you only want to run parts of the platform, you can use the following run commands from the root project:

* **start:dev** - Synonym to `npm run start`
* **start:web** - Only starts the web management platform
* **start:ws** - Only starts the WebSocket service for notification center updates
* **start:widget** - Starts the widget wrapper project that hosts the notification center inside an iframe
* **start:api** - Runs the API in watch mode
* **start:worker** - Runs the worker application in watch mode
* **start:dal** - Runs the Data Access Layer package in watch mode
* **start:shared** - Starts the watch mode for the shared client and API library
* **start:node** - Runs the `@novu/node` package in watch mode
* **start:notification-center** - Runs and builds the React package for the Novu notification center

<iframe />

<iframe />

### Set up your environment variables

If you have used Jarvis CLI tool from the previous step you don't need to setup the env variables as Jarvis will do that on the first run if setup wasn't done before.

The command `npm run setup:project` creates default environment variables that are required to run Novu in a development environment. However, if you want to test certain parts of Novu or run it in production mode, you need to change some of them. These are all the available environment variables:

<AccordionGroup>
  <Accordion title="API Backend">
    * `NODE_ENV` (default: local)The environment of the app. Possible values are: dev, test, production, ci, local
    * `S3_LOCAL_STACK`The AWS endpoint for the S3 Bucket required for storing various media
    * `S3_BUCKET_NAME`The name of the S3 Bucket
    * `S3_REGION`The AWS region of the S3 Bucket
    * `PORT`The port on which the API backend should listen on
    * `FRONT_BASE_URL`The base url on which your frontend is accessible for the user. (e.g. web.novu.co)
    * `DISABLE_USER_REGISTRATION` (default: false)If users should not be able to create new accounts. Possible values are: true, false
    * `REDIS_HOST`The domain / IP of your redis instance
    * `REDIS_PORT`The port of your redis instance
    * `REDIS_PASSWORD`Optional password of your redis instance
    * `REDIS_DB_INDEX`The Redis database index
    * `REDIS_CACHE_SERVICE_HOST`The domain / IP of your redis instance for caching
    * `REDIS_CACHE_SERVICE_PORT`The port of your redis instance for caching
    * `REDIS_CACHE_DB_INDEX`The Redis cache database index
    * `REDIS_CACHE_TTL`The Redis cache ttl
    * `REDIS_CACHE_PASSWORD`The Redis cache password
    * `REDIS_CACHE_CONNECTION_TIMEOUT`The Redis cache connection timeout
    * `REDIS_CACHE_KEEP_ALIVE`The Redis cache TCP keep alive on the socket timeout
    * `REDIS_CACHE_FAMILY`The Redis cache IP stack version
    * `REDIS_CACHE_KEY_PREFIX`The Redis cache prefix prepend to all keys
    * `REDIS_CACHE_SERVICE_TLS`The Redis cache TLS connection support
    * `IN_MEMORY_CLUSTER_MODE_ENABLED`The flag that enables the cluster mode. It might be Redis or ElastiCache cluster, depending on the env variables set for either service.
    * `ELASTICACHE_CLUSTER_SERVICE_HOST`ElastiCache cluster host
    * `ELASTICACHE_CLUSTER_SERVICE_PORT`ElastiCache cluster port
    * `REDIS_CLUSTER_SERVICE_HOST`Redis cluster host
    * `REDIS_CLUSTER_SERVICE_PORTS`Redis cluster ports
    * `REDIS_CLUSTER_DB_INDEX`Redis cluster database index
    * `REDIS_CLUSTER_TTL`Redis cluster ttl
    * `REDIS_CLUSTER_PASSWORD`Redis cluster password
    * `REDIS_CLUSTER_CONNECTION_TIMEOUT`Redis cluster connection timeout
    * `REDIS_CLUSTER_KEEP_ALIVE`Redis cluster TCP keep alive on the socket timeout
    * `REDIS_CLUSTER_FAMILY`Redis cluster IP stack version
    * `REDIS_CLUSTER_KEY_PREFIX`Redis cluster prefix prepend to all keys
    * `JWT_SECRET`The secret keybase which is used to encrypt / verify the tokens issued for authentication
    * `SENDGRID_API_KEY`The api key of the Sendgrid account used to send various emails
    * `MONGO_URL`The URL of your MongoDB instance
    * `MONGO_MAX_POOL_SIZE`The max pool size of the MongoDB connection
    * `NOVU_API_KEY`The api key of web.novu.co used to send various emails
    * `SENTRY_DSN`The DSN of sentry.io used to report errors happening in production
  </Accordion>

  <Accordion title="Worker">
    * `NODE_ENV` (default: local)The environment of the app. Possible values are: dev, test, production, ci, local
    * `PORT`The port on which the Worker app should listen on
    * `STORE_ENCRYPTION_KEY`The encryption key used to encrypt/decrypt provider credentials
    * `MAX_NOVU_INTEGRATION_MAIL_REQUESTS`The number of free emails that can be sent with the Novu email provider
    * `NOVU_EMAIL_INTEGRATION_API_KEY`The Novu email provider Sentry API key
    * `STORAGE_SERVICE`The storage service name: AWS, GCS, or AZURE
    * `S3_LOCAL_STACK`The LocalStack service URL
    * `S3_BUCKET_NAME`The name of the S3 Bucket
    * `S3_REGION`The AWS region of the S3 Bucket
    * `GCS_BUCKET_NAME`The name of the GCS Bucket
    * `AZURE_ACCOUNT_NAME`The name of the Azure account
    * `AZURE_ACCOUNT_KEY`The Azure account key
    * `AZURE_HOST_NAME`The Azure host name
    * `AZURE_CONTAINER_NAME`The Azure container name
    * `AWS_ACCESS_KEY_ID`The AWS access key
    * `AWS_SECRET_ACCESS_KEY`The AWS secret access key
    * `REDIS_HOST`The domain / IP of your redis instance
    * `REDIS_PORT`The port of your redis instance
    * `REDIS_PASSWORD`Optional password of your redis instance
    * `REDIS_DB_INDEX`The Redis database index
    * `REDIS_CACHE_SERVICE_HOST`The domain / IP of your redis instance for caching
    * `REDIS_CACHE_SERVICE_PORT`The port of your redis instance for caching
    * `REDIS_DB_INDEX`The Redis cache database index
    * `REDIS_CACHE_TTL`The Redis cache ttl
    * `REDIS_CACHE_PASSWORD`The Redis cache password
    * `REDIS_CACHE_CONNECTION_TIMEOUT`The Redis cache connection timeout
    * `REDIS_CACHE_KEEP_ALIVE`The Redis cache TCP keep alive on the socket timeout
    * `REDIS_CACHE_FAMILY`The Redis cache IP stack version
    * `REDIS_CACHE_KEY_PREFIX`The Redis cache prefix prepend to all keys
    * `REDIS_CACHE_SERVICE_TLS`The Redis cache TLS connection support
    * `IN_MEMORY_CLUSTER_MODE_ENABLED`The flag that enables the cluster mode. It might be Redis or ElastiCache cluster, depending on the env variables set for either service.
    * `ELASTICACHE_CLUSTER_SERVICE_HOST`ElastiCache cluster host
    * `ELASTICACHE_CLUSTER_SERVICE_PORT`ElastiCache cluster port
    * `REDIS_CLUSTER_SERVICE_HOST`Redis cluster host
    * `REDIS_CLUSTER_SERVICE_PORTS`Redis cluster ports
    * `REDIS_CLUSTER_DB_INDEX`Redis cluster database index
    * `REDIS_CLUSTER_TTL`Redis cluster ttl
    * `REDIS_CLUSTER_PASSWORD`Redis cluster password
    * `REDIS_CLUSTER_CONNECTION_TIMEOUT`Redis cluster connection timeout
    * `REDIS_CLUSTER_KEEP_ALIVE`Redis cluster TCP keep alive on the socket timeout
    * `REDIS_CLUSTER_FAMILY`Redis cluster IP stack version
    * `REDIS_CLUSTER_KEY_PREFIX`Redis cluster prefix prepend to all keys
    * `MONGO_URL`The URL of your MongoDB instance
    * `MONGO_MAX_POOL_SIZE`The max pool size of the MongoDB connection
    * `NEW_RELIC_APP_NAME`The New Relic app name
    * `NEW_RELIC_LICENSE_KEY`The New Relic license key
    * `SEGMENT_TOKEN`The Segment Analytics token
  </Accordion>

  <Accordion title="Web Client">
    * `REACT_APP_ENVIRONMENT` The environment of the app. Possible values are: dev, test, production, ci, local
    * `REACT_APP_API_URL` The base url on which your API backend would be accessible
    * `REACT_APP_WS_URL` The base url on which your WebSocket service would be accessible
    * `SKIP_PREFLIGHT_CHECK` (default: true)Solves a problem with React App dependency tree.

    <Warning>
      When configuring different than default values for the API and WebSocket URLs,
      in order for the Web app to apply the changes done to the `./env` file, it is
      needed to run the script `pnpm envsetup`. This will generate a file
      called `env-config.js` that will be copied inside of the `public` folder of
      the application. Its purpose is to inject in the `window._env_`object the
      chosen environment variables that manage the URLs the Web client will call to
      access to the API backend and the WebSocket service.
    </Warning>
  </Accordion>

  <Accordion title="Web Socket">
    * `NODE_ENV` (default: local)The environment of the app. Possible values are: dev, test, production, ci, local
    * `SENTRY_DSN`The DSN of sentry.io used to report errors happening in production
    * `REDIS_HOST`The domain / IP of your redis instance
    * `REDIS_PORT`The port of your redis instance
    * `REDIS_DB_INDEX`The database index of your redis instance
    * `REDIS_PASSWORD`Optional password of your redis instance
    * `JWT_SECRET`The secret keybase which is used to encrypt / verify the tokens issued for authentication
    * `MONGO_URL`The URL of your MongoDB instance
    * `MONGO_MAX_POOL_SIZE`The max pool size of the MongoDB connection
    * `PORT`The port on which the WebSocket service should listen on
  </Accordion>
</AccordionGroup>

### Running tests

After making changes, you can run the tests for the respective package using the appropriate CLI commands:

### API

To run the API tests, run the following command:

```shell theme={null}
npm run start:worker:test
npm run start:e2e:api
```

The tests create a new instance of Novu and a test db and run the tests against it. The test db is removed after all tests have finished running.

### Web

To run the front end tests for the web project using cypress you need to install localstack. The cypress tests perform E2E tests. To be able to perform E2E tests, you need to run the API service in the appropriate test environment.

Run the services in test env with the following commands:

```shell theme={null}
npm run start:web
npm run start:api:test
npm run start:worker:test
npm run start:ws:test
```

Run the cypress test suite with the following command:

```shell theme={null}
cd apps/web && npm run cypress:run
```

To open the cypress management window to debug tests, run the following commands:

```shell theme={null}
cd apps/web && npm run cypress:open
```

### Different ports used by the services

* **3000** - API
* **3002** - WebSocket Service
* **3003** - Webhook Service
* **3004** - Worker Service
* **4200** - Web Management UI
* **4701** - Iframe embed for notification center
* **4500** - Widget Service

### Testing providers

To run tests against the providers’ folder, you can use the `npm run test:providers` command.

### Local environment setup script (beta)

As an option in our script runner `Jarvis` we have made available an option to run [this script](https://github.com/novuhq/novu/blob/2f2abdcaaad8a7735e0a2d488607c3276c8975fd/scripts/dev-environment-setup.sh) that will automatically try to install all the dependencies needed to be able to run Novu locally, as the previous step of installing the project dependencies through `pnpm install`. When executing it inside `Jarvis`, you will need to have previously installed by yourself `git` and `node`, as we mentioned earlier on this page.

The script can be run on its own without any previous dependency installed, as it is prepared to execute the following tasks:

* Check the running OS in the local machine (currently only MacOSx and [GNU Linux](https://en.wikipedia.org/wiki/GNU/Linux_naming_controversy)supported)
* Install of OS dependencies (currently only MacOSx supported) -- MacOSx: It will execute the following tasks --- Will try to install or update [XCode](https://developer.apple.com/xcode/) (skippable step; though XCode installs `[git](https://git-scm.com/)` that is a required dependency for later) --- Will install [Rosetta](https://support.apple.com/en-gb/HT211861) for Apple CPUs --- Will set up some opinionated OS settings
* Will check if `[git](https://git-scm.com/)` is installed and if not will abort the operation
* Will make [ZSH](https://en.wikipedia.org/wiki/Z_shell) the default shell to be able to execute the next task
* Will (opinionatedly) install [Oh My Zsh!](https://ohmyz.sh/) (skippable task)
* Will (opinionatedly) install the [Homebrew](https://brew.sh/) package manager and will set up your local environment to execute it besides adding some casks
* Will (opinionatedly) install [NVM](https://github.com/nvm-sh/nvm) as a Node.js version manager
* Will install the required [Node.js](https://nodejs.org/en/) version to be able to [run Novu](https://github.com/novuhq/novu/blob/2f2abdcaaad8a7735e0a2d488607c3276c8975fd/package.json#L180)
* Will install [PNPM](https://pnpm.io/) as a package manager, required dependency for some of the tasks inside Novu's scripts
* Will install [Docker](https://www.docker.com/) as containerized application development tool
* Will install required databases [MongoDB](https://www.mongodb.com/) (Community version) and [Redis](https://redis.io/) through Homebrew
* Will install the [AWS CLI](https://aws.amazon.com/cli/) tool (not required to run Novu; it is a core maintainer used tool)
* Will create a local development domain `local.novu.co` in your local machine
* Will clone the Novu repository in your local machine (skippable step) to a selected folder `$HOME/Dev`

<Warning>
  This script has only been thoroughly tested in MacOSx. Little testing has been
  run in GNU Linux.
</Warning>

<Info>
  This script is not bullet-proof and some of the tasks have intertwined
  dependencies with each other. We have tried to make it as idempotent as
  possible but some loose knots will probably show because of conflicts between
  versions of the different dependencies. Please report to us any problem found
  and we will try to fix or assist though we do not have the resources to make
  it idempotent in every potential system and potential combinations
</Info>


# Windows
Source: https://v0.x-docs.novu.co/community/windows-machine-setup

Learn how to configure your local Windows machine to run Novu

## Setting up git

To set up git and create an access token for GitHub, suggested installing [GitHub Desktop](https://www.notion.so/Dev-Machine-Setup-98d274c80fa249b0b0be75b9a7a72acb?pvs=21) before.

## Development Environment

### Node & NVM

To easily manage multiple node versions you can use [NVM for Windows](https://github.com/coreybutler/nvm-windows) a (Node Version Manager alternative for Windows).

Download the .exe installation file for NVM for Windows [here](https://github.com/coreybutler/nvm-windows/releases).

After installing NVM for Windows, check that the installation is successfull and added to path by running `nvm -v` on a terminal.

<Note>
  After installing NVM, if you get `nvm: command not found` or see
  no feedback from your terminal after you type `nvm -v`, simply **close
  your current terminal, open a new terminal**, and try verifying again.
</Note>

Once nvm is installed and working you can install any version of Node using the syntax `nvm install vX.Y.Z` and to switch to a node version,
run `nvm use vX.Y.Z`. Novu requires node v20.8.1 or higher:

```shell theme={null}
nvm install v18.17.0
nvm use v18.17.0
```

### PNPM

For package management, we use [PNPM](https://pnpm.io/) instead of npm or yarn to speed up our install times and space efficiency. To install pnpm globally run:

```shell theme={null}
npm install -g pnpm
```

### MongoDB

for detailed instructions on installing MongoDB community edition on a Windows machine please refere to the MongoDB doc [here](https://www.mongodb.com/docs/manual/tutorial/install-mongodb-on-windows).

After installation, whether you have installed as a Windows service or just the binaries, ensure that the MongoDB instance is started before you proceed.

### Redis

To install Redis for local development you'll first need to enable WSL2 (Windows Subsystem for Linux). detailed instructions for installing
WSL can be found [here](https://learn.microsoft.com/en-us/windows/wsl/install)

If you have WSL installed and enabled, you can easily install Redis using the native procedure for the Linux distribution that you have installed.
for Ubuntu or Debian which is the default distro installed by WSL, use the following commands

1. First install `lsb-release`, `curl` and `gpg` if you do not already have them:

```shell theme={null}
sudo apt install lsb-release curl gpg
```

2. Add the repository to the apt index, update it, and then install:

```shell theme={null}
curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg

echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list

sudo apt-get update
sudo apt-get install redis
```

3. Lastly, start the Redis server like so:

```shell theme={null}
sudo service redis-server start
```

### Docker

Docker is not a requirement to run Novu on your local machine, but if you would prefer to use Docker, Follow the installation guide on [docker website](https://docs.docker.com/desktop/install/windows-install/) to install **Docker Desktop** on your Windows machine.

### AWS CLI

Follow the instructions to install the AWS CLI so you can use it to create env later on, based on existing S3 buckets:

[Installing or updating the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

You should get something like this:

<img alt="AWS CLI" />

If needed, see:

[Resolve "Unable to locate credentials" error in Amazon S3](https://aws.amazon.com/premiumsupport/knowledge-center/s3-locate-credentials-error/)

### Local dev domain (Optional)

This will allow you to use [local.novu.co](http://local.novu.co) instead of [localhost](http://localhost) when accessing the service on your machine.

Navigate to `C:\Windows\System32\drivers\etc` in the file explorer and open the `hosts` file with a text editor (like Notepad):

<Note>
  Note that this file can only be edited when running as an Administrator.
</Note>

And add the [local.novu.co](http://local.novu.co) domain and save.

```shell theme={null}
127.0.0.1       local.novu.co
```

### Code Editor

Feel free to install your favorite code editor. We supply licenses for [WebStorm](https://www.notion.so/WebStorm-7570ab1037bf494d88d0f9b544ae3b79?pvs=21), or you can [Visual Studio Code](https://code.visualstudio.com/download) if you prefer it.

### Productivity tools

* GitHub Desktop (Optional)

GitHub Desktop simplifies the development workflow and interaction with Git. [Download](https://desktop.github.com/) the client from their website.


# Brand
Source: https://v0.x-docs.novu.co/content-creation-design/brand



Through Novu's web dashboard, you have the power to effortlessly tailor your brand settings, streamlining the process of creating notifications. Customize key elements such as your logo, which will be seamlessly integrated into your email communications.

For those utilizing Novu's In-App notification center, the ability to configure the primary font and its corresponding color awaits you. This empowers you to craft an experience for your users that resonates with your unique brand identity.

<img />


# Handlebars & Helpers
Source: https://v0.x-docs.novu.co/content-creation-design/handlebars-helpers



# Handlebars

The Novu notification content editor relies on Handlebars.js to establish the logic and control flow of our workflows.
For a deeper comprehension of Handlebars.js, you can refer to its [documentation](https://handlebarsjs.com/guide/#what-is-handlebars).

This resource offers comprehensive insights into the utilization of Handlebars.js in crafting dynamic and adaptable notification content within the Novu platform.

| Helper          | Description                                                                     | Example                                                          | Output                                                |
| --------------- | ------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ----------------------------------------------------- |
| if              | Conditionally renders a block. Falsy values won't be rendered.                  | `{{#if author}}<h1>{{firstName}} {{lastName}}</h1>{{/if}}`       | Renders `<h1>Yehuda Katz</h1>` if `author` is truthy. |
| includeZero     | `includeZero=true` treats the conditional as not empty, handling 0 differently. | `{{#if 0 includeZero=true}}<h1>Does render</h1>{{/if}}`          | Renders `<h1>Does render</h1>` for 0.                 |
| Sub-Expressions | Create custom logic helpers and use them in sub-expressions.                    | `{{#if (isdefined value1)}}true{{else}}false{{/if}}`             | Renders `true` or `false` based on custom helper.     |
| unless          | Inverse of if helper. Renders a block if the expression is falsy.               | `{{#unless license}}<h3 class="warning">WARNING</h3>{{/unless}}` | Renders warning if `license` is falsy.                |
| each            | Iterate over a list. Use this to reference the iterated element.                | `{{#each people}}<li>{{this}}</li>{{/each}}`                     | Renders list items.                                   |
| with            | Change context for template parts.                                              | `{{#with person}}{{firstname}} {{lastname}}{{/with}}`            | Renders `firstname` and `lastname` from the context.  |
| Nested each     | Access iteration variables in nested each blocks.                               | `{{#each array}}{{@index}}: {{this}}{{/each}}`                   | Renders index and item in each iteration.             |
| Nested with     | Use with block parameters for clear code.                                       | See above example with nested with and complex template.         | Renders nested context values.                        |
|                 | You can use else section to handle empty values.                                | `{{#with city}}...{{else}}No city found{{/with}}`                | Handles empty context case.                           |

# Novu-specific helpers

| Handlebar Expression                       | Description                                                                                                                                                                                                                           |
| ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `{{dateFormat date 'EEEE, MMMM Do yyyy'}}` | You can format the date using the `dateFormat` function. Here, `date: '2020-01-01'` has been formatted into `Wednesday, January 1st 2020`.                                                                                            |
| `{{lowercase key}}`                        | This helps you use the `lowercase` handlebar helper function and turns the value of the specified key to its lowercase value. So, for `message: 'hEllo WORLD'`, if we write `{{lowercase message}}`, we'll end up with `hello world`. |
| `{{uppercase key}}`                        | This helps you use the `uppercase` handlebar helper function and turns the value of the specified key to its uppercase value. So, for `message: 'hello woRld'`, if we write `{{uppercase message}}`, we'll end up with `HELLO WORLD`. |
| `{{titlecase key}}`                        | This helps you use the `titlecase` handlebar helper function and turns the value of the specified key to its titlecase value. So, for `message: 'hEllo wOrLD'`, if we write `{{titlecase message}}`, we'll end up with `Hello World`. |

### groupBy

`groupBy` helper is used to group the items in an array based on a property.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    {{#each (groupBy names "name")}}
      <h1>{{key}}<h1>
      {{#each items}}
        <h3>{{age}}</h3>
      {{/each}}
    {{/each}}
    ```
  </Tab>

  <Tab title="Context">
    ```json theme={null}
    {
      "names": [
        {
          "name": "Name 1",
          "age": "30"
        },
        {
          "name": "Name 2",
          "age": "31"
        },
        {
          "name": "Name 1",
          "age": "32"
        }
      ]
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
    <h1>Name 1<h1>
    <h3>30</h3>
    <h3>32</h3>
    <h1>Name 2<h1>
    <h3>31</h3>
    ```
  </Tab>
</Tabs>

### equals

`equals` helper allows you to perform comparisons, both for boolean expressions and string comparisons.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    <!-- LOGIC -->
    {{#equals value1 value2}}
       <!-- Code to execute when value1 is equal to value2 -->
    {{else}}
       <!-- Code to execute when value1 is not equal to value2 -->
    {{/equals}}


    <!-- Example -->
    {{#equals 10 1}}
       <h2> 10 is equal to 1 </h2>
    {{else}}
       <h1> 10 is not equal to 1 </h1>
    {{/equals}}
    ```
  </Tab>

  <Tab title="Context">
    ```json theme={null}
    {
      "value1" : 10,
      "values2" : 1
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
       <h1> 10 is not equal to 1 </h1>
    ```
  </Tab>
</Tabs>

### numberFormat

`numberFormat` helper is used to format numbers with specified decimal length, thousands separator, and decimal separator.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    <div>{{numberFormat number decimalSep="," decimalLength="2" thousandsSep="|"}}</div>
    <div>{{numberFormat nonNumber decimalSep="," decimalLength="2" thousandsSep="|"}}</div>
    ```
  </Tab>

  <Tab title="Context">
    ```json theme={null}
    {
      "number": 1000000000,
      "nonNumber": "Not a number"
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
    <div>1|000|000|000,00</div>
    <div>Not a number</div>
    ```
  </Tab>
</Tabs>

### pluralize

The `pluralize` helper allows you to easily handle pluralization in your templates by providing different forms of a word depending on a variable value.

### Basic Usage

In its simplest form, the `pluralize` helper takes three arguments:

```
{{pluralize count singular plural}}
```

* `count`: The numeric value that determines whether the singular or plural form should be used.
* `singular`: The singular form of the word.
* `plural`: The plural form of the word.

#### Example

```
{{pluralize dog_count "dog" "dogs"}}
```

In this example, if `dog_count` is equal to 1, it will render "1 dog," and if it's greater than 1, it will render "dogs."

## Use Cases & Examples

### Handling Event Count Display with Excluded Individuals

In some cases, you may want to display the total count of certain events but exclude specific individuals who are already mentioned. For example, when using a phrase like "John and `{{step.total_count}}` people liked your photo," you may notice that the count is off by one because "John" is already mentioned.

To account for such scenarios, you can utilize the following approach:

```
{{#each step.events}}
  {{#if @first}}
    {{this.name}}
  {{else}}
    {{#if @last}}
      and {{@index}}
    {{/if}}
  {{/if}}
{{/each}}
followed you!
```

In this code, we iterate through the `step.events` array and conditionally display each name. If it's the first name in the list, it will be shown without "and." For subsequent names, we add "and" before the last name. This ensures that the count is not affected by names that are explicitly mentioned in the message.

By using this code, you can achieve a more accurate representation of the event count in your messages, even when some users are individually mentioned in the message text.

### Using array length as count

Array length be used as total number of item. For example, if paylod have fruits property of type array then its length can be used as total number of fruits.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    Total number of fruits is {{fruits.length}}.
    ```
  </Tab>

  <Tab title="Payload">
    ```json theme={null}
    {
      "fruits": [
        {
          "name": "Pine apple",
          "price": "10$"
        },
        {
          "name": "Apple",
          "age": "8$"
        },
        {
          "name": "Orange",
          "age": "5$"
        }
      ]
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
    Total number of fruits is 3.
    ```
  </Tab>
</Tabs>

<Note> In a future release, we plan to replace handlebar helpers with an alternative solution. Please note that custom handlebars in the editor itself are not currently supported. If we are missing any handlebar helper that is blocking you to write template for use case, feel free to reach out to us in [discord](https://discord.gg/novu?ref=docs-handlebar-helper)</Note>


# Layouts
Source: https://v0.x-docs.novu.co/content-creation-design/layouts

Explore how to create and manage layouts in Novu

### Email Layouts

Novu allows the creation of layouts - a specific HTML design or structure to wrap content of email notifications. Layouts can be manipulated and assigned to new or existing workflows within the Novu platform, allowing users to create, manage, and assign these layouts to workflows, so they can be reused to structure the appearance of notifications sent through the platform.

By default, Novu will create a default layout and assign it as the organization's default layout. At any time, you can choose any of your layouts as the default for your organization. All new email templates will be assigned the default layout unless assigned a different one through the email editor.

#### Manage Layouts

You can find and manage your organization's layouts in `Brand -> Layouts`

<img />

#### Create and Edit Layouts

You can create new or edit existing layouts through the layout editor.

* You can create any html code to structure your layout.
* Set a layout as default for your organization. Notice there could only be one default layout at a time.
* Manage layout variables - set default values or required variables.

<img />

<Info> Layout content must include `{{{body}}}`, to indicate where the email editor content will be injected inside the layout. </Info>

#### Assign layout to workflow

To assign, choose a layout through the email editor. You can preview your layout combined with your email content through the `Preview` tab.

<img />

#### Override layout on trigger

To override your assigned layout during a trigger event, use the `layoutIdentifier` property.

The layout specified will be used for all emails in the context of that trigger event.

```ts theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

novu.trigger('workflow-identifier', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    attachments: [
      {
        file: fs.readFileSync(__dirname + '/data/test.jpeg'),
        name: 'test.jpeg',
        mime: 'image/jpg',
      },
    ],
  },
  overrides: {
    layoutIdentifier: 'your-layout-identifier',
  },
});
```

<Note> The override layout on trigger functionality is only available on v0.19.0.</Note>

#### Using SDK

Novu SDK supports all layout functionalities:

#### Create a new layout

A new layout can be created with name, description, content, variables and an `isDefault` flag. Here, content param is html content with custom variables.

```tsx theme={null}
const name: string = "layout-name";
const description: string =
  "The description of the layout that will help other users to understand the goal it was created"; // Optional.
const content: string = "<EMAIL_LAYOUT>";
const variables: ITemplateVariable[] = []; // Optional. Will handle the placeholder variables inserted in the email layout (content).
const isDefault: boolean = true; // Optional. All layouts are created as non default if not stated otherwise.

const { _id: layoutId } = await novu.layouts.create({
  name,
  description,
  content,
  variables,
  isDefault,
});
```

```tsx theme={null}
interface ITemplateVariable {
  type: TemplateVariableTypeEnum;
  name: string;
  required?: boolean;
  defaultValue?: string | boolean;
}

enum TemplateVariableTypeEnum {
  STRING = "String",
  ARRAY = "Array",
  BOOLEAN = "Boolean",
}
```

#### Update existing layout

When updating a layout, all properties are optional and the SDK will only update the ones passed.

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout.

const updatedLayout = await novu.layouts.update(layoutId, {
  name,
  description,
  content,
  variables,
  isDefault,
});
```

#### Set default layout

When executing this, the existing default layout in the environment will be automatically set as non default and the chosen layout will be set as default. This action is non reversible.

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout to be set as default.

await novu.layouts.setDefault(layoutId);
```

#### Delete an existing layout

Layouts can also be deleted. The condition to be able to delete a layout is that it is not a default layout and is not assigned in any existing workflow.

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout to be deleted.

await novu.layouts.delete(layoutId);
```

#### Get a layout

Find a layout by layoutId

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout to be found.

const layout = await novu.layouts.get(layoutId);
```

#### List all layouts

List paginated layouts

```tsx theme={null}
const page: number = 0; // Pagination value of the page for the results. First page will be page = 0.
const pageSize: number = 100; // Optional. Pagination value of the amount of layouts per page to return.
const sortBy: string = "createdAt"; // Optional. Property to order the list of the layouts. So far only `createdAt` is supported.
const orderBy: OrderDirectionEnum = -1; // Optional. Direction of the sorting by the property chosen in `sortBy`. Ascendent order is represented by 1 and descendent order is represented by -1.

const layouts = await novu.layouts.list({
  page,
  pageSize,
  sortBy,
  orderBy,
});
```

## API Reference Links

* [Layout Methods](/api-reference/layouts/layout-creation/)


# Content Creation
Source: https://v0.x-docs.novu.co/content-creation-design/notification-content-creation

Explore how to create notification content

To demonstrate the extensive range of possibilities, we've crafted a subscriber profile enriched with various attributes to highlight the flexibility of our system.

```typescript theme={null}
const subscriber = {
    subscriberId: '6427e97d0136cef86a315c46',
    firstName: 'John',
    lastName: 'Doe',
    email: 'john.doe@gmail.com',
    phone: '+98712345677',
    avatar: 'https://sm.ign.com/ign_nordic/cover/a/avatar-gen/avatar-generations_prsz.jpg',
    locale: 'en-US',
    data: {
        plan: 'basic',
        zipcode: 14925,
        validVehicleLicense: true
    }
};
```

Let's go over examples for each communication channel:

## Email

There are multiple ways to craft your email notification content for maximum impact.

<Note>
  Please remember that you have the option to preview the anticipated output of
  your input using the editor. Simply switch from the editing mode to the
  preview mode to see the results.
</Note>

### Regular Editor

Example: Send a personalized welcome email to a user by leveraging their properties.

**Input:**

```html theme={null}
Hello {{subscriber.firstName}} {{subscriber.lastName}}!

We are excited to welcome you to our {{subscriber.data.plan}} plan.
Look forward to receiving daily updates from us on your phone number: {{subscriber.phone}}.

{{#if subscriber.data.validVehicleLicense}}
Why not consider renting a car to visit us?
{{else}}
We're delighted to offer you a train ticket to come see us.
{{/if}}

Should you require any assistance, don't hesitate to reach out.
Best regards,
Your friends at Novu.
```

<img />

**Output:**

```html theme={null}
Hello John Doe!

We are excited to welcome you to our basic plan.
Look forward to receiving daily updates from us on your phone
number: +98712345677.

Why not consider renting a car to visit us?
Should you require any assistance, don't hesitate to reach out.
Best regards,
Your friends at Novu.
```

<img />

### Custom Code Editor

**Input:**

<Accordion title="Email Template Example">
  ```HTML theme={null}
  <!DOCTYPE html>
  <html>
  <head>
    <meta charset="UTF-8">
    <title>Welcome to Novu!</title>
    <style>
        /* Inline styles for email compatibility */
        body {
            font-family: 'Helvetica Neue', Arial, sans-serif;
            background-color: #f4f4f4;
            margin: 0;
            padding: 0;
        }
        .container {
            max-width: 600px;
            margin: 0 auto;
            padding: 20px;
            background-color: #ffffff;
            border-radius: 10px;
            box-shadow: 0 3px 6px rgba(0, 0, 0, 0.1);
        }
        .header {
            text-align: center;
            margin-bottom: 20px;
        }
        .message {
            font-size: 16px;
            line-height: 1.6;
            color: #333333;
            margin-bottom: 20px;
        }
        .cta-button {
            display: inline-block;
            padding: 10px 20px;
            background-color: #007bff;
            color: #ffffff;
            text-decoration: none;
            border-radius: 5px;
            font-weight: bold;
        }
        .signature {
            margin-top: 20px;
            font-style: italic;
            color: #888888;
        }
    </style>
  </head>
  <body>
    <div class="container">
        <div class="header">
            <h1 style="color: #007bff;">Welcome to Novu!</h1>
        </div>
        <div class="message">
            <p>Hello {{subscriber.firstName}} {{subscriber.lastName}}!</p>
            <p>We are thrilled to have you on board with our {{subscriber.data.plan}} plan.</p>
            <p>Get ready to receive daily updates on your phone: {{subscriber.phone}}.</p>
            <p>{{#if subscriber.data.validVehicleLicense}}
                We would like to offer you renting a car to visit us.
            {{else}}
                We would like to buy you a train ticket to visit us.
            {{/if}}</p>
            <p>If you need any assistance or have questions, feel free to reach out.</p>
            <p><a class="cta-button" href="#">Explore Your Options</a></p>
        </div>
        <div class="signature">
            <p>Best regards,<br>Your friends at Novu</p>
        </div>
    </div>
  </body>
  </html>
  ```
</Accordion>

<img />

**Output:**

<img />

<Info>Email Subject, Sender Name and Preheader field accepts system, payload variables and handlebar helpers</Info>
[Explore how to manage Email layouts.](/content-creation-design/layouts)

## In-App

The In-App notification content editor closely resembles the Email notification editor, although with some discernible differences.

<img />

You can:

* Transform notifications into clickable links, redirecting to your specified URLs
* Enjoy unlimited character freedom
* Utilize all variables to craft dynamic and personalized messages
* Infuse your brand's essence with customizable elements
* Drive engagement with action buttons
* Embed avatar images
* Preview the expected output

## SMS

When crafting your SMS notification, you can tap into all the available variables and even add dynamic ones.

<img />

## Chat

We make it effortless to send notifications to chat providers like Slack, Microsoft Teams, and Discord. Meet your users in the tools they use daily.
You have the ability to utilize all variables to craft dynamic and personalized messages.

<img />

## Push

Push channel has two fields `Push Message Title` and `Push Message Content` where user can write hard coded text content or use system, dynamic variables or handlebar helpers to customize notification content.

<img />


# Translations
Source: https://v0.x-docs.novu.co/content-creation-design/translations

Translate notification content to different languages using i18n.

<Info>The feature is only available for **Novu Cloud** users with **Business** or **Enterprise** plans.</Info>

## Introduction

The Translation Management feature allows you to seamlessly adapt your workflows to different languages and automatically apply them based on your customers' locales. It enhances engagement, personalizes the user experience, and allows you to expand your market reach.

To understand how Translation Management works in Novu we need to review its main pillars:

* Translation Groups
* Translation Files
* Localized Message Content
* Subscribers locale

## Translation Groups

Translation Group allows you to efficiently manage translations for diverse languages with shared business significance. For example, the Branding translation group can hold the content related to your company identity, while the Marketing translation group can exclusively house content related to your marketing campaigns. You aren't obligated to divide your translation content, you can manage it all within a single translation group.

To create the Translation Group navigate to the `Translations` page from the main navigation and click on the “Add group” button.

<img />

Before creating your first Translation Group you'll be prompted to specify the default locale for organization. This locale serves as a fallback option for localized messages in cases where the recipient hasn't defined a specific locale.

<img />

After selecting the default language, you can provide the essential details: the group name, group identifier, and select your target languages.

The group identifier is an important value that you will later use in the editor to localize your messages. This is a similar concept that we use across the app to identify the main parts.

<img />

After the group is created, you will land on the group details page on which you can see the list with the empty translations for the languages you choose.

<img />

## Translations

Translations are JSON files that contain the content of your messages in a specific language. For example, if you created a Marketing translation group with two target languages English and German, then your translation JSON files might look like this:

**English (en.json):**

```json theme={null}
{
  "welcome_message": "Welcome to our Marketing Campaign!",
  "learn_more": "Learn More",
  "special_offer": "Special Offer",
  "contact_us": "Contact Us"
}
```

**German (de.json):**

```json theme={null}
{
  "welcome_message": "Willkommen bei unserer Marketingkampagne!",
  "learn_more": "Mehr erfahren",
  "special_offer": "Sonderangebot",
  "contact_us": "Kontaktieren Sie uns"
}
```

To upload your translations click on the “Upload files” button located at the top of the Translation Group details page.

<img />

Select the translation files and click “Open” button.

<img />

With each uploaded translation file, you must indicate the language it references. Additionally, you can verify the correctness of the uploaded file by previewing its contents.

<img />

Click on “Upload files” button. Congratulations you just uploaded the translation files and created the translation group! 🎉

### Localized Message Content

To localize your message content, you need to use the translation variables in the editor. The variables allow you to reference the values from the translation files. It consists of the `i18n` [handlebar](https://docs.novu.co/content-creation-design/handlebars-helpers) helper and path to the translated value.

Let’s take a look at the example: `{{i18n "marketing.welcome_message"}}`.

* `i18n` is the handlebar helper that tells Novu that you would like to use the Translations
* `"marketing.welcome_message"` is the path that is composed of the Translation Group identifier `marketing` and translation JSON file key `welcome_message`

<img />

<Info>i18n variables can be used in `subject` and `preheader` fields of the email step.</Info>

## Subscribers Locale

The subscribers locale defines in which language the message should be delivered to that recipient. When the locale is not specified it will fallback to the default locale set for the organization. The locale format includes ISO language plus the region, for example `de_DE` language German and region Germany.

To update the locale you can use Novu API or any of our SDKs, more information can be found [here](https://docs.novu.co/subscribers/subscribers).

## Editor Examples

### Variables

It is possible to include variables in your translation strings, they should be wrapped in double curly brackets. Their value could be set as a string or as a variable - either a system variable or a variable sent through the payload.

```json theme={null}
{
  "withVariables": "Welcome {{name}} to {{organization}}"
}
```

In the editor:

```handlebars theme={null}
{{i18n "welcome.withVariables" name=subscriber.firstName organization="Novu"}}
```

### Context

By providing a context you can differ translations. Eg. useful to provide gender specific translations.

For example:

```json theme={null}
{
	"friend": "A friend",
	"friend_male": "A boyfriend",
	"friend_female": "A girlfriend"
}
```

In the editor:

```handlebars theme={null}
{{i18n "welcome.friend" context="male"}}
```

Will result in the message `A boyfriend`. Not adding any context will output `A friend`.

### Plurals

To distinguish between plural translation options.

```json theme={null}
{
	"keyWithCount": "{{count}} item",
	"keyWithCount_plural": "{{count}} items",
}
```

In the editor:

```handlebars theme={null}
{{i18n "welcome.keyWithCount" count=7}}
```

Will result in `7 items`

### Date formats

To control date formats, do as follows:

```json theme={null}
{
  "date": "Current date: {{date, dd/MM/yyyy}}",
  "try_date": "Current date: {{date, MM/dd/yyyy}}",
  "intlDateTime": "On the {{date, HH:yyyy}}"
}
```

In the editor:

<Tip>
  Date can be a string or a variable you send in the payload as `{ date: new Date() }`
</Tip>

```handlebars theme={null}
{{i18n "welcome.date" date="12-06-2023"}}
{{i18n "welcome.try_date" date=date}}
{{i18n "welcome.intlDateTime" date=date}}
```


# Workflow Editor
Source: https://v0.x-docs.novu.co/content-creation-design/variables



Novu's content creation tools allow developers to utilize a wealth of variables when designing notification workflows.

As developers construct workflows using Novu, certain status facets—results of batch functions and other steps in the workflow—are auto-generated and can be utilized to control the content displayed in notification templates.

These variables offer dynamic and automated properties that hold subscriber information, such as first and last name, email, phone, and avatar.

For example, developers can insert a subscriber's first name into a workflow by using `{{ subscriber.firstName }}`.

In addition to the subscriber's details, developers can use data payload variables that encapsulate dynamic data meant to be injected into the content of a workflow.

For instance, in the code example the variables username and resetLink are data payload variables that would be adjusted based on the workflow's purpose.

**The utilization of these variables allows Novu to deliver personalized notifications to the receiver, thus improving user experience and accomplishing better communication outcomes.**

## System Variables

### Subscriber Variables

| Variable       | Type     | Description                                                                   |
| -------------- | -------- | ----------------------------------------------------------------------------- |
| `subscriber`   | `Object` | Represents someone who is intended to receive a notification.                 |
| `firstName`    | `String` | The first name of the subscriber.                                             |
| `lastName`     | `String` | The last name of the subscriber.                                              |
| `email`        | `String` | The subscriber's email address.                                               |
| `phone`        | `String` | The phone number associated with the subscriber.                              |
| `avatar`       | `String` | A URL or reference to the subscriber’s avatar or profile picture.             |
| `locale`       | `String` | The preferred locale or language of the subscriber.                           |
| `subscriberId` | `String` | Unique identifier for the subscriber.                                         |
| `data`         | `Object` | An additional object that can hold custom subscriber data as key-value pairs. |

### Actor Variables

| Variable       | Type     | Description                                                              |
| -------------- | -------- | ------------------------------------------------------------------------ |
| `actor`        | `Object` | A subscriber who initiates actions triggering events.                    |
| `firstName`    | `String` | The first name of the actor.                                             |
| `lastName`     | `String` | The last name of the actor.                                              |
| `email`        | `String` | The actor's email address.                                               |
| `phone`        | `String` | The phone number associated with the actor.                              |
| `avatar`       | `String` | A URL or reference to the actor’s avatar or profile picture.             |
| `locale`       | `String` | The preferred locale or language of the actor.                           |
| `subscriberId` | `String` | Unique identifier for the actor.                                         |
| `data`         | `Object` | An additional object that can hold custom actor data as key-value pairs. |

### Step Variables

| Variable      | Type      | Description                                                                 |
| ------------- | --------- | --------------------------------------------------------------------------- |
| `step`        | `Object`  | A component in the execution of a workflow.                                 |
| `digest`      | `Boolean` | Indicates whether digest mode is active or not.                             |
| `events`      | `Array`   | An aggregated collection of events (that are stored when digest is active). |
| `total_count` | `Number`  | Represents the total number of events in the digest.                        |

### Brand Variables

| Variable   | Type     | Description                                                                 |
| ---------- | -------- | --------------------------------------------------------------------------- |
| `branding` | `Object` | Enables customization of the notification's visual identity.                |
| `logo`     | `String` | Insert the brand logo.                                                      |
| `color`    | `String` | Set the primary color of the notification based on the brand configuration. |

### Tenant Variables

| Variable | Type     | Description                                                               |
| -------- | -------- | ------------------------------------------------------------------------- |
| `tenant` | `Object` | Group of users or an organization.                                        |
| `name`   | `String` | Insert the brand logo.                                                    |
| `data`   | `Object` | An additional object that can hold custom tenant data as key-value pairs. |

## Data Payload Variables

Data payload variables encompass the dynamic data intended to be injected into the content of a workflow. These variables are integral components of the payload object, forming part of the parameters for the trigger function.

Here's a more illustrative example of how data payload variables can be employed:

```jsx theme={null}
curl -L -X POST 'https://api.novu.co/v1/events/trigger' \
-H 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
-H 'Content-Type: application/json' \
--data-raw '{
    "name": "password-reset",
    "to": {
        "subscriberId": "6427e97d0136cef86a315c46",
        "email": "john.doe@acme.com"
    },
    "payload": {
        "username": "Jhontheman1969",
        "resetLink": "http://sample.info/password.reset",
        "securityEmail": "john.doe.backup@acme.com",
    }
}'
```

Within this code snippet, the variables `username` and `resetLink` are representative of data payload variables.

Importantly, it's worth noting that the payload itself can encompass any serializable JSON object.

<Info>Avoid use of system reserved variables as normal variables. For example don't use `email` as variable name because `{{subscriber.email}}` is a system reserved variable</Info>


# Bridge Endpoint
Source: https://v0.x-docs.novu.co/framework/concepts/endpoint



## Bridge Endpoint

Novu Framework requires a **single** `HTTP` endpoint (`/api/novu` or similar) to be exposed by your application. This endpoint is used to receive events from our Worker Engine.

You can view the Bridge Endpoint as a webhook endpoint that Novu will call when it needs to retrieve contextual information for a given subscriber and notification.

Using the `create-novu-app` command creates a Bridge application for you with a Bridge endpoint ready to go.

## The `serve` function

We offer framework specific wrappers in form of an exported `serve` function that abstracts away:

* Parsing the incoming request for `GET`, `POST`, `PUT` and `OPTIONS` requests
* HMAC header authentication
* Framework specific response and error handling

Currently, we offer `serve` functions for the following frameworks:

* [Next.js](/framework/sdk/frameworks/nextjs)
* [Express.js](/framework/sdk/frameworks/express)
* [Nuxt](/framework/sdk/frameworks/nuxt)
* [h3](/framework/sdk/frameworks/h3)
* [Remix](/framework/sdk/frameworks/remix)
* [Sveltekit](/framework/sdk/frameworks/sveltekit)

## Writing a custom `serve` function

If we currently don't support your framework, you can write a custom `serve` function like the following example:

```ts theme={null}
import { type Request, type Response } from 'express';
import { NovuRequestHandler, ServeHandlerOptions } from '@novu/framework';

export const serve = (options: ServeHandlerOptions): any => {
  const requestHandler = new NovuRequestHandler({
    frameworkName: 'express',
    ...options,
    handler: (
      incomingRequest: Request,
      response: Response,
    ) => ({
        method: () => incomingRequest.method,
        headers: (key) => {
            const header = incomingRequest.headers[key];
            return Array.isArray(header) ? header[0] : header;
        },
        queryString: (key) => {
                const qs = incomingRequest.query[key];
                return Array.isArray(qs) ? qs[0] : qs;
        },
        body: () => incomingRequest.body,
        url: () => new URL(incomingRequest.url, `https://${incomingRequest.headers.get("host") || ""}`),
        transformResponse: ({ body, headers, status }) => {
            Object.entries(headers).forEach(([headerName, headerValue]) => {
              response.setHeader(headerName, headerValue);
            });

            return response.status(status).send(body);
       },
    }),
  });

  return requestHandler.createHandler();
};
```


# Step Inputs
Source: https://v0.x-docs.novu.co/framework/concepts/inputs



Inputs are defined using [JSON Schema](/framework/recipes/json-schema), providing a strong run-time validation system for your workflows.

This ensures that you as the developer, and your non-technical peers are speaking the same language.
Those responsible for styling and copy can edit with confidence, knowing their changes are tested in code.

## Inputs vs Payload

**Inputs** - For Non-Technical Peers and Developers. Managed in the Novu Web UI, defined by developers and used by non-technical peers.

<Info>
  **Examples** - Color of a button, text of a button, should a section be shown, digest duration, static text content, the order of the email sections, and etc...
</Info>

**Payload Schema** - For Developers. Passed during the `novu.trigger` method, and controlled by the developer.

<Info>
  **Examples** - User ID, Post ID, Comment, Order ID, 2FA token and etc...
</Info>

## Step Inputs

[Step](/framework/concepts/steps) input schema is defining the input passed during the `step` method. Those inputs can be modified and persisted in the Novu Web UI.

The snippet below shows configuration for the Workflow payload schema and the Step input schema. If you don’t provide a schema, Typescript will infer the data type to `unknown`, reminding you of the best practice to specify your schema.

```tsx theme={null}
workflow('new-signup', async ({ step, payload }) => {
    await step.email(
      'send-email',
      async (inputs) => {
          return {
            subject: inputs.subjectTitle,
            body: render(<ReactEmailContent hideBanner={inputs.hideBanner} components={inputs.components} />),
        }
      }, {
	      // Learn about JSON Schema here: https://json-schema.org/specification
        inputSchema: {
	        // Always `object`
          type: 'object',
          // Specify the properties to validate. Supports deep nesting.
          properties: {
            hideBanner: { type: 'boolean', default: false },
            subjectTitle: { type: 'string' },
            // Allowing no code control over the component in the Web UI
            components: {
                type: "array",
                items: {
                    type: "string"
                },
                default: ["header", "cta-row", "footer"]
            }
          },
          // Specify the array of which properties are required.
          required: ['complianceFooter'],
          // Used to enforce full type strictness, with no rogue properties.
          additionalProperties: false,
		      // The `as const` is important to let Typescript know that this
		      // type won't change, enabling strong typing on `inputs` via type
		      // inference of the provided JSON Schema.
        } as const,
      });
});
```

Learn more about [JSON Schema here](https://json-schema.org/specification), including the powerful validation features to ensure your Content renders perfectly, every time.

<Note>
  Other validators, including Zod and more, coming soon.
  Any validator that supports transformation to JSON Schema can be added.
</Note>

## JSON Schema Examples

To Learn more about advanced examples, visit our [JSON Schema](/framework/recipes/json-schema) page.


# Payload
Source: https://v0.x-docs.novu.co/framework/concepts/payload



Workflow payload is the data passed during the `novu.trigger` method. This is useful for ensuring that the payload is correctly formatted and that the data is valid.

## Payload Schema

Payload schema is defining the payload passed during the `novu.trigger` method. This is useful for ensuring that the payload is correctly formatted and that the data is valid.

```tsx theme={null}
workflow('comment-on-post', async ({ step, payload }) => {
    await step.email(
      'send-email',
      async () => {
          return {
            subject: `You have a new comment from: ${payload.author_name}.`,
            body: render(<ReactEmailContent comment={payload.comment} />),
        }
      });
  },
  {
    payloadSchema: {
            // Always `object`
          type: 'object',
          // Specify the properties to validate. Supports deep nesting.
          properties: {
            post_id: { type: 'number' },
            author_name: { type: 'string' },
            comment: { type: 'string', maxLength: 200 },
          },
          // Specify the array of which properties are required.
          required: ['post_id', 'comment'],
          // Used to enforce full type strictness, with no rogue properties.
          additionalProperties: false,
		      // The `as const` is important to let Typescript know that this
		      // type won't change, enabling strong typing on `inputs` via type
		      // inference of the provided JSON Schema.
        } as const,
  },
);
```

## Passing Payload

Here is an example of the validated payload during trigger:

```tsx theme={null}
novu.trigger('comment-on-post', {
    to: 'subscriber_id',
    payload: {
        post_id: 1234,
        author_name: 'John Doe',
        comment: 'Looks good!'
    }
});
```


# Dev Studio
Source: https://v0.x-docs.novu.co/framework/concepts/studio



The Echo Dev Studio is a companion app to the Echo Client SDK. Its goal is to provide a local environment that lives near your code.

To launch the dev studio locally you can run: `npx novu-labs@latest echo` . The Dev Studio will be started by default on port 2022, and accessible via: `http://localhost:2022`

After successfully connecting the Studio to your local edge endpoint, you will be able to preview in real time any workflows and content defined in your code. This is ideal for quick prototyping, debugging, styling, and adjusting your workflows before syncing them to Novu Cloud.

### Inputs and Payload forms

You can quickly modify the step inputs and workflow payload to preview your workflow's different states and be generated with. This is helpful to quickly debug how the email will behave in case of a missing input, or iterate more complex content structures.

### Syncing State

Sync state to your Production or Development environment in Novu, is recommended to do via your CI pipeline. However, a sync can be made using the Dev Studio for quick experimentation.

Click on the `Sync` button at the top right corner of the navigation bar, and a Diff will be generated between your local and the Novu Cloud environments.

After inspecting the State Diff, and specifying the remote `Echo Url` Click on the `Deploy Changes` button.

### **Debugging locally**

To allow Novu to communicate with your local machine a tunnel will need to be generated. The quickest way to do it is with `localtunnel.` To Create a new tunnel in your terminal, type: `npx localtunnel --port <YOUR_EDGE_PORT>` . This command will return an https endpoint, which then can be used during the sync state flow described earlier.


# Workflows
Source: https://v0.x-docs.novu.co/framework/concepts/workflows

Workflows are at the core of responding to events in your system with notifications. Novu Framework enables you to declare type-safe, validated, and version-controlled Novu Workflows with code.

## Introduction

The most basic Workflow to send a notification in response to an event looks like:

```tsx theme={null}
import { workflow } from '@novu/framework';

const myWorkflow = workflow('new-signup', async ({ step, payload }) => {
	// Send a welcome email
  await step.email('send-email', async () => {
    return {
      subject: `Welcome to Acme, ${payload.name}`,
      body: 'We look forward to helping you achieve mission.',
    }
  });
  // JSON Schema for validation and type-safety. Zod, and others coming soon.
}, { payloadSchema: { properties: { name: { type: 'string' }}}} );
```

## Just-in-time data fetching

You can add any custom logic into your steps that you need. Maybe you’d like to fetch some information about your new sign-up from somewhere else during the Workflow execution. You can achieve it with the following changes:

```tsx theme={null}
const myWorkflow = workflow('new-signup', async ({ step, payload }) => {
	// Send a welcome email
  await step.email('send-email', async () => {
	  // Fetch the user from your database
	  const user = await db.getUser(payload.userId);
        return {
          subject: `Welcome to Acme ${user.productTier} tier, ${user.name}.`,
          // 'Welcome to Acme Business tier, John Doe.'
          body: 'We look forward to helping you achieve mission.',
        }
      });
      // Changing the schema from `name` -> `userId`, for type-safety.
    }, { payloadSchema: { properties: { userId: { type: 'string' }}}} );
```

We call this **just-in-time** notification data fetching. It allows you pull in data from the relevant sources during the Workflow execution, removing the need to store all of your subscriber data in Novu.

## Multi-step workflow

Now, what if you wanted to send another update to the same new user in 1 week? But, you don't want to send the follow-up if the User opted out. We can add more steps to the Workflow to achieve this.

```tsx theme={null}
const myWorkflow = workflow(
  'new-signup',
  async ({ step, payload }) => {
    await step.email('send-email', async () => {
      const user = await db.getUser(payload.userId);
      return {
        subject: `Welcome to Acme ${user.productTier} tier, ${user.name}.`,
        body: 'We look forward to helping you achieve mission.',
      };
    });

    // Wait for 1 week before continuing. After 1 week, Novu will continue
    // executing the Workflow from here.
    await step.delay('onboarding-follow-up', async () => ({
      amount: 1,
      type: 'regular',
      unit: 'weeks',
    }));

    // 1 week passed, let's follow up with an in-app notification.
    await step.inApp(
      'onboarding-follow-up',
      async (inputs) => {
        const user = await db.getUser(payload.userId);
        // The `feedbackUrl` can be updated in Novu Web without changing code.
        // This helps you to create re-usable Workflow snippets.
        return {
          body: `Hey ${user.name}! How do you like the product?

      Let us know <a href="${inputs.feedbackUrl}">here</a>
      if you have any questions.`,
        };
      },
      {
        // Don't follow up if the Subscriber opted out.
        skip: () => !payload.shouldFollowUp,
        // Add validation to ensure `feedbackUrl` provided in Web is a `uri`
        inputSchema: {
          type: 'object',
          properties: { feedbackUrl: { type: 'string', format: 'uri', default: 'https://acme.com/feedback' } },
          required: ['feedbackUrl'],
          additionalProperties: false,
        } as const,
      },
    );
  },
  {
    payloadSchema: {
      type: 'object',
      properties: {
        userId: { type: 'string' },
        shouldFollowUp: { type: 'boolean', default: true },
      },
      required: ['userId', 'shouldFollowUp'],
      additionalProperties: false,
    } as const,
  },
);
```

With this simple Workflow, we:

* Sent a new signup email
* Waited 1 week
* Sent an in-app follow-up notification

You should now have a grasp of the flexibility that Novu Framework offers.

Continue your reading in [Steps](/framework/concepts/steps) to find out the other channels and actions you can use with Novu Framework.

## Workflow Interface

```tsx theme={null}
workflow(
	// the Workflow name. Must be unique across your Bridge server.
	'new-signup',
	// Workflow resolver, the entry-point for your Workflow steps
	async ({
		// Helper function to declare your Workflow Steps.
		step,
		// Workflow Trigger payload
		payload,
	}) => {
	// ...your Workflow Steps

}, {
	// JSON Schema for validation and type-safety. Zod, and others coming soon.
	// https://json-schema.org/draft-07/json-schema-release-notes

	// The schema for the Workflow payload passed dynamically via Novu Trigger API
	// Defaults to an empty schema.
	payloadSchema: { properties: { name: { type: 'string' }}},
	// The schema for the Workflow inputs passed statically via Novu Web
	// Defaults to an empty schema.
	inputSchema: { properties: { brandColor: { type: 'string' }}},
});
```


# Quick Start
Source: https://v0.x-docs.novu.co/framework/quickstart

Novu Framework, the Code-first notification workflow engine. Build advanced workflows while giving your non-technical teammates complete control over content and behavior.

<Note>
  **Novu Framework is currently in public Alpha.** Need help? Have a suggestion? Join our [Discord community](https://discord.gg/novu).
</Note>

## Introduction to Novu Framework

Novu Framework allows you to write notification workflows in your codebase. Workflows are functions that execute business logic and use your preferred libraries for email, SMS, and chat generation. You can use Novu Framework with [React.Email](https://react.email/), [MJML](https://mjml.io/), or any other template generator.

<EchoTerminal />

## Try it now

To create a new Bridge application that will allow you to define your workflow in code, open your terminal and execute the `create-novu-app` command.

```shell theme={null}
npx create-novu-app@latest --api-key=<API_KEY_HERE>
```

The command will ask you if you wish to install from a React.Email template or a clean project.

## Core features

<CardGroup>
  <Card title="Bring Your Own Code" icon="code">
    Write the notification workflows as functions in your codebase,  version, and manage them using Git.
  </Card>

  <Card title="Limitless Integrations" icon="plug" href={'/framework/integrations'}>
    Use React.email, MJML, or fetch templates from Braze, Hubspot, Sendgrid, and more...
  </Card>

  <Card title="Type Safety" icon="shield">
    Bring your own schemas for full, end-to-end validation and type safety.
  </Card>

  <Card title="Cloud Synchronization" icon="cloud">
    Sync your workflows with Novu Cloud and ease collaboration.
  </Card>
</CardGroup>

## How it Works?

Novu Framework introduces a new paradigm when working with Novu. Rather than defining workflows and templates at Novu Cloud, Novu Framework enables you to work in your application, use your own libraries and connect to your production environment during workflow execution over HTTPS.

The Novu Framework exports the client you use to define and serve your workflows and their steps over HTTPS. The workflows can be added to your preferred framework. During workflow execution Novu Cloud makes HTTPS requests to your Bridge server for *just-in-time* Content and Subscribers resolution.

<Frame>
  <img />
</Frame>

## For Non-Technical Users

Novu Framework was built with non-technical user in mind. Engineers can write complex workflows and expose a type-safe [Inputs](/framework/concepts/inputs) interface powered by JSON-Schema.
This enables Non-Technical teammates to safely modify the workflow without breaking mission critical notifications.


# Roadmap
Source: https://v0.x-docs.novu.co/framework/roadmap



This document outlines the roadmap for the Novu Framework project. It is a living document and will be updated as the project progresses.

Our goal with Novu Framework is to create a Code-First but Product in-mind. Here you can see parts of our roadmap and future plans for it:

Looking to add a feature request or upvote and existing feature? Head over to our [Public Roadmap](https://roadmap.novu.co).

## Novu Framework, Now and Next

* ✅ **Workflows**: the ability to create multi-step workflows and manage them using Code.
* ✅ **CLI**: a command-line interface to interact with Novu Framework.
* ✅ **Studio**: a visual front to preview your local work.
* ✅ **Step Inputs**: JSON-Schema based interface for not technical users to modify the workflow content and behaviour.
* ✅ **GitHub Actions**: sync your workflows using GitHub Actions.
* ✅ **In App Seen/Read**: the ability to see the status of the in-app message.
* ✅ **Custom Step**: the ability to create custom and execute custom code in the workflow. For example: custom provider, retrieving database information, and 3rd party service integration.
* 🔜 **Zod Schema**: the ability to define the schema for the workflow and step inputs using Zod.
* 🔜 **Define Integrations**: code-first approach of creating and managing your provider integrations
* 🔜 **Email Reply Hook**: executing a custom logic code when a user replies to the email.
* 🔜 **Webhook**: receive webhooks about the execution flow of a workflow in Novu Framework.
* 🔜 **Eslint Plugin**: follow best practices and avoid common mistakes when writing code for Novu Framework.
* 🔜 **Codegen**: use our community driven list of workflow templates to use out of the box.


# Introduction
Source: https://v0.x-docs.novu.co/framework/sdk/client



See the snippet below to learn how to configure your Bridge endpoint application.

```tsx theme={null}
import { Client } from '@novu/framework';

const client = new Client({
  /**
   * Specify a custom Novu API URL.
   * Defaults to 'https://api.novu.co', for EU use: https://eu.api.novu.co
   */
	apiUrl: 'https://api.novu.co',
  /**
   * Specify your Novu API key, to secure your Bridge API endpoint.
   * Novu communicates securely with your endpoint using a signed HMAC header,
   * ensuring that only trusted requests from Novu are actioned by your Bridge API.
   * The API key is used to sign the HMAC header.
   */
	apiKey: process.env.NOVU_API_KEY,
  /**
   * Explicitly use HMAC signature verification.
   * Setting this to `false` will enable Novu to communicate with your Bridge API
   * without requiring a valid HMAC signature.
   * This is useful for local development and testing.
   *
   * You are strongly encouraged to specify an `apiKey` and set this to `true` in production,
   * to ensure that only trusted requests from Novu are actioned by your Bridge API.
   *
   * Defaults to true.
   */
	strictAuthentication: process.env.NODE_ENV !== "development",
});
```


# Integrate Novu with Next.js
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/nextjs



## App Router

<CodeGroup>
  ```ts app/api/novu/route.ts theme={null}
  import { serve } from "@novu/framework/next";
  import { myWorkflow } from "../../novu/workflows";

  export const { GET, POST, PUT, OPTIONS } = serve({ workflows: [myWorkflow] });
  ```
</CodeGroup>

## Pages Router

<CodeGroup>
  ```ts pages/api/novu.ts theme={null}
  import { serve } from "@novu/framework/next";
  import { myWorkflow } from '../../novu/workflows';

  export default serve({ workflows: [myWorkflow] });
  ```
</CodeGroup>

Check out a comprehensive [guide on sending notifications in Next.js with React email](/guides/framework-guides/framework-react-email).


# Chat Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/chat



Use the chat channel step to send a message for providers like: Slack, WhatsApp, Discord and others.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
});
```

## Provider Overrides

Some providers offer a rich DSL for styling the messages. Novu Framework offers a robust API to leverage the provider specific capabilities using the step `providers` option object.

Let's see an example of how to send a message to Slack using the `providers` option objet.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
}, {
    providers: {
        slack: ({ inputs }) => ({
            text: 'A new post has been created',
            blocks: [
                {
                    type: 'section',
                    text: {
                        type: 'mrkdwn',
                        text: 'A new post has been created',
                    },
                },
            ],
        }),
    }
});
```

Default chat `body` field is still specified as a fallback value in case a provider specific configuration is not used.

<Info>
  Currently we only support `Slack` provider overrides. We are working on adding more providers.
</Info>


# Custom Action Step
Source: https://v0.x-docs.novu.co/framework/steps/custom

Used to execute any custom code as a step in the workflow.

A custom steps allows to execute any custom logic and persist in the durable execution context. The result of this step can be used in subsequent steps.

## Common usecases

* Making an API call to 3rd party service
* Fetch data from a database to be used in subsequent steps
* Execute a custom logic to transform data
* Custom provider implementation

## Custom Step Interface

```tsx theme={null}
const stepResult = await step.custom('custom-step', async () => {
  return {
    item_name: 'A product name',
    item_price: 100,
  };
}, {
    outputSchema: {
        type: 'object',
        properties: {
            item_name: { type: 'string' },
            item_price: { type: 'number' },
        },
        required: ['item_name', 'item_price'],
    }
});
```

### Output Schema Definition

This JSON Schema definition is used to validate the output of the custom step. If the output does not match the schema, the workflow will fail.
Novu Framework will infer the Typescript interface from the JSON Schema definition.

### Return Value

The Custom Step function should return a valid serializable object. The return value will be persisted in the durable execution context.

## Using the Custom Step Result

The result can only be used in the `resolver` of the step/providers/skip functions of subsequent steps.

```typescript theme={null}
workflow('hello-world-workflow', async ({ payload }) => {
    const task = await step.custom('fetch-db-data', async () => {
        const taskData = db.fetchTask(payload.task_id);
        return {
            task_id: taskData.id,
            task_title: taskData.title,
            complete: taskData.complete,
        };
    }, {
        outputSchema: {
            type: 'object',
            properties: {
                task_title: { type: 'string' },
                task_id: { type: 'string' },
                complete: { type: 'boolean' },
            },
            required: ['task_id', 'complete'],
        }
    });

    await step.email('send-email', () => {
        return {
            subject: `Task reminder for ${task.task_title}`,
            body: 'Task is not yet complete. Please complete the task.'
        }
    }, {
        // Only send the reminder E-mail if the task is not complete
        skip: () => !task.complete
    })
});



```


# Delay Action Step
Source: https://v0.x-docs.novu.co/framework/steps/delay



Use the delay action whenever you need to pause the execution of your workflow for a period of time.

```tsx theme={null}
await step.delay('delay-1-week', async () => {
  return {
	  unit: 'weeks', // 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
	  amount: 1, // the number of units to delay workflow execution for
	};
});
```


# Digest Action Step
Source: https://v0.x-docs.novu.co/framework/steps/digest



The digest engine is designed to streamline notifications by accumulating multiple trigger events into one coherent message before delivery to the subscriber.

This function proves beneficial when a user needs to be alerted about numerous triggers, but it's important to minimize the frequency of notifications. Novu automates this process, batching incoming trigger events according to a unique subscriberId. There is also the option to include a digestKey, providing additional control over event digestion workflows.

## Step Interface

```tsx theme={null}
const digestResult = await step.digest('digest-3-days', async () => {
  return {
	  unit: 'days', // 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
	  amount: 3, // the number of units to digest events for
	};
});
```

## Using the digested triggers

The digest function returns an array of triggers that have been digested.
You can use this array to perform any necessary actions on the digested triggers. Like Sending and email, or updating a database.

```tsx theme={null}
const digestResult = await step.digest('digest-3-days', async () => {
  return {
	  unit: 'days', // 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
	  amount: 3, // the number of units to digest events for
	};
});

await step.email('send-email', async () => {
  return {
    subject: 'Digest Email',
    body: `You have ${digestResult.events.length} new events`,
 };
});
```

The digest step returns an object with `events` array. Each event in the array has the following properties:

* `id` - The `job id` of the digested event
* `time` - The time when the event was triggered
* `payload` - The original payload passed to the event


# Email Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/email



E-mail expected to be an object with the following properties:

* `subject` - The subject of the email
* `body` - The HTML body of the email

Any content generation framework like [React Email](/framework/integrations/react-email) can be used here to generate the HTML Content.

```tsx theme={null}
await step.email('send-email', async (inputs) => {
  return {
    subject: 'You received a post',
    body: `<html><body>A new post has been created</body></html>`,
  };
});
```


# In-App Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/in-app



Novu offers notification center component that can be easily embedded into your application. Read more about it [here](/notification-center/introduction).

```tsx theme={null}
await step.inApp('send-in-app', async (inputs) => {
  return {
    body: `A new post has been created`,
  };
});
```


# Workflow Steps
Source: https://v0.x-docs.novu.co/framework/steps/introduction

Steps control the execution flow of your workflow, whilst Novu provides the context of your notification delivery events back into the Workflow execution context.

## Supported Steps

Novu Supports Channel and Action steps to be used as part of the workflow execution.

### Channel Steps

* [E-mail](/framework/steps/email)
* [Chat](/framework/steps/chat)
* [SMS](/framework/steps/sms)
* [Push](/framework/steps/push)
* [In-App](/framework/steps/in-app)

### Action steps

* [Delay](/framework/steps/delay)
* [Digest](/framework/steps/digest)

## Channel Steps Interface

Channel steps are used to send notifications to your Subscribers. Each channel can optionally configure the provider to customize content, enabling you to create enhanced content aligned with the specification of the provider. For example, you might like to use Slack blocks to send your Chat message.

All channels follow the same interface:

```tsx theme={null}
await step.email('new-post', async (inputs) => {
    return {
        subject: 'You received a post',
        body: `<html><body>A new post has been created</body></html>`,
    }
}, options);
```

* `new-post` is the unique to the workflow identifier for this step. You cannot have 2 steps using the same identifier
* `resolver` function, used to return the content of the channel.
* `options` this is an optional configuration object that defines: [Input Schema](/framework/concepts/inputs), [Provider Overrides](#provider-overrides), skip and other configurations...

## Provider Overrides

Provider overrides are used to customize the content of the notification for a specific provider. For example, you might like to use Slack blocks to send your Chat message.

Those overrides are mapped directly to the provider specific SDKs, so you can use the same properties and methods that you would use in the provider SDK.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
}, {
    providers: {
        slack: ({ inputs }) => ({
            text: 'A new post has been created',
            blocks: [
                {
                    type: 'section',
                    text: {
                        type: 'mrkdwn',
                        text: 'A new post has been created',
                    },
                },
            ],
        }),
    }
});
```

<Info>
  Currently we only support `Slack` provider overrides. We are working on adding more providers.
</Info>

When overriding a provider specific behavior, Novu still requires the default content to be returned from the resolver function.
This is because the default content is used for the fallback provider, or when the provider override is not available.

## Skip Step

A step can be conditionally skipped by returning `true` from the resolver function. This is helpful when you want to use your existing user-preference system instead of Novu.
Or conditionally skip a step if it's not relevant any more for delivery.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
}, {
    skip: () => true,
});
```


# Push Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/push



```tsx theme={null}
await step.push('send-push', async () => {
  return {
    subject: 'You received a post',
    body: 'A new post has been created',
  };
});
```


# SMS Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/sms



```tsx theme={null}
await step.sms('send-sms', async () => {
  return {
    body: 'A new post has been created',
  };
});
```


# Backend SDK methods
Source: https://v0.x-docs.novu.co/notification-center/backend/methods



### Fetch subscriber’s In-App notifications feed

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: inAppMessages } = await novu.subscribers.getNotificationsFeed(
    "subscriberId",
    {
      page: 0,
      limit: 10,

      // it is of type string. By default all feeds messages are fetched
      feedIdentifier: "Product Updates",

      // seen and read filter of type boolean
      seen: true,
      read: true,
    }
  );
  ```
</CodeGroup>

### Fetch all Messages Sent To All Subscribers

<CodeGroup>
  ```javascript Node.JS theme={null}
  import { ChannelTypeEnum } from "@novu/node";

  // All fields are optional
  const listMessagesOptions = {
    // pagination options
    page: 0,
    limit: 20,

    /**
     *  Filter options
     */
    // use ChannelTypeEnum.PUSH for push, ChannelTypeEnum.EMAIL for email,
    channel: ChannelTypeEnum.IN_APP, // only In-App type messages will be fetched
    subscriberId: "6444105141ffb0919496dfcb",
    transactionIds: ["644-41051-41ffb0-919496-dfcb"],
  };

  const { data: messagesData } = await novu.messages.list(listMessagesOptions);
  ```
</CodeGroup>

### Delete an In-App notification/message

<CodeGroup>
  ```javascript Node.JS theme={null}
  // messageId is of MongoDB Id type
  await novu.messages.deleteById("messageId");
  ```
</CodeGroup>

### Mark an In-App Message as Read/Seen

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: markMessageAsRead } = await novu.subscribers.markMessageRead(
    "subscriberId",
    "messageId"
  );

  const { data: markMessageAsSeen } = await novu.subscribers.markMessageSeen(
    "subscriberId",
    "messageId"
  );
  ```
</CodeGroup>

### Mark an In-App Message as Read/Unread/Seen/Unseen

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: markMessageAs } = await novu.subscribers.markMessageAs(
    "subscriberId",
    "messageId",
    { seen: true, read: false }
  );
  ```
</CodeGroup>

### Mark all In-App Messages as Read/Unread/Seen/Unseen

<CodeGroup>
  ```javascript Node.JS theme={null}
  import { MarkMessagesAsEnum } from "@novu/node"

  const { data: markAllInAppMessages } = await novu.subscribers.markAllMessagesAs(
     'subscriberId',

     // can be filtered with feed identifiers
     feedIdentifier: ['Marketing', 'Product']

     // MarkMessageAsEnum.READ => It will mark all messages as read
     // MarkMessageAsEnum.SEEN => It will mark all messages as seen
     // MarkMessageAsEnum.UNREAD => It will mark all messages as unread
     // MarkMessageAsEnum.UNSEEN => It will mark all messages as unseen
     markAs: MarkMessageAsEnum.Read
  );
  ```
</CodeGroup>

### Fetch All Feeds

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: feedsData } = await novu.feeds.get();
  ```
</CodeGroup>


# Headless API Reference
Source: https://v0.x-docs.novu.co/notification-center/client/headless/api-reference



This page contains the complete documentation about the Headless Notification Center package. You can find here the list of all the methods that you can use.

## initializeSession

To use the headless service, you'll need to initialize the session first. This sets the token and starts the socket listener service.

```typescript theme={null}
headlessService.initializeSession({
  listener: (result: FetchResult<ISession>) => {
    console.log(result);
  },
  onSuccess: (session: ISession) => {
    console.log(session);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IInitializeSession {
  listener: (result: FetchResult<ISession>) => void;
  onSuccess?: (session: ISession) => void;
  onError?: (error: unknown) => void;
}
```

## fetchOrganization

Fetches the details of the current organization

```typescript theme={null}
headlessService.fetchOrganization({
  listener: (result: FetchResult<IOrganizationEntity>) => {
    console.log(result);
  },
  onSuccess: (organization: IOrganizationEntity) => {
    console.log(organization);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchOrganization {
  listener: (result: FetchResult<IOrganizationEntity>) => void;
  onSuccess?: (session: IOrganizationEntity) => void;
  onError?: (error: unknown) => void;
}
```

## fetchUnseenCount

Fetches the count of unseen messages

```typescript theme={null}
headlessService.fetchUnseenCount({
  listener: (result: FetchResult<{ count: number }>) => {
    console.log(result);
  },
  onSuccess: (data: { count: number }) => {
    console.log(data);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchUnseenCount {
  listener: (result: FetchResult<{ count: number }>) => void;
  onSuccess?: (data: { count: number }) => void;
  onError?: (error: unknown) => void;
}
```

## fetchUnreadCount

Fetches the count of unread messages

```typescript theme={null}
headlessService.fetchUnreadCount({
  listener: (result: FetchResult<{ count: number }>) => {
    console.log(result);
  },
  onSuccess: (data: { count: number }) => {
    console.log(data);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchUnreadCount {
  listener: (result: FetchResult<{ count: number }>) => void;
  onSuccess?: (data: { count: number }) => void;
  onError?: (error: unknown) => void;
}
```

## listenNotificationReceive

Listens to a new notification being added. Can be used to retrieve a new notification in real-time and trigger UI changes.

```typescript theme={null}
headlessService.listenNotificationReceive({
  listener: (message: IMessage) => {
    console.log(JSON.stringify(message));
  },
});
```

### method args interface

```typescript theme={null}
interface IListenNotificationReceive {
  listener: (message: IMessage) => void;
}
```

## listenUnseenCountChange

Listens to the changes of the unseen count. Can be used to get real time count of the unseen messages.

```typescript theme={null}
headlessService.listenUnseenCountChange({
  listener: (unseenCount: number) => {
    console.log(unseenCount);
  },
});
```

### method args interface

```typescript theme={null}
interface IListenUnseenCountChanget {
  listener: (unseenCount: number) => void;
}
```

## listenUnreadCountChange

Listens to the changes of the unread count. Can be used to get real time count of the unread messages.

```typescript theme={null}
headlessService.listenUnreadCountChange({
  listener: (unreadCount: number) => {
    console.log(unreadCount);
  },
});
```

### method args interface

```typescript theme={null}
interface IListenUnreadCountChanget {
  listener: (unreadCount: number) => void;
}
```

## fetchNotifications

Retrieves the list of notifications for the subscriber. Can also be used to get the notifications of a particular tab.

```typescript theme={null}
headlessService.fetchNotifications({
  listener: (result: FetchResult<IPaginatedResponse<IMessage>>) => {
    console.log(result);
  },
  onSuccess: (response: IPaginatedResponse<IMessage>) => {
    console.log(
      response.data,
      response.page,
      response.totalCount,
      response.pageSize
    );
  },
  page: pageNumber,
  query: { 
    feedIdentifier: "feedId", 
    read: false, 
    seen: true, 
    // payload sent while triggering the workflow
    payload: {
      message : "Notification message",
      type: "product",
    } 
  },
  storeId: "storeId",
});
```

### method args interface

```typescript theme={null}
interface IFetchNotifications {
  page?: number;
  storeId?: string;
  query?: IStoreQuery;
  listener: (result: FetchResult<IPaginatedResponse<IMessage>>) => void;
  onSuccess?: (messages: IPaginatedResponse<IMessage>) => void;
  onError?: (error: unknown) => void;
}
```

## fetchUserPreferences

Fetches the user [preferences](/subscribers/preferences)

```typescript theme={null}
headlessService.fetchUserPreferences({
  listener: (result: FetchResult<IUserPreferenceSettings[]>) => {
    console.log(result);
  },
  onSuccess: (settings: IUserPreferenceSettings[]) => {
    console.log(settings);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchUserPreferences {
  listener: (result: FetchResult<IUserPreferenceSettings[]>) => void;
  onSuccess?: (settings: IUserPreferenceSettings[]) => void;
  onError?: (error: unknown) => void;
}
```

## updateUserPreferences

Updates the user [preferences](/subscribers/preferences).

```typescript theme={null}
headlessService.updateUserPreferences({
  listener: (
    result: UpdateResult<
      IUserPreferenceSettings,
      unknown,
      IUpdateUserPreferencesVariables
    >
  ) => {
    console.log(result);
  },
  onSuccess: (settings: IUserPreferenceSettings) => {
    console.log(settings);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  templateId: "templateId",
  channelType: "SMS",
  checked: true,
});
```

### method args interface

```typescript theme={null}
interface IUpdateUserPreferences {
  templateId: IUpdateUserPreferencesVariables["templateId"];
  channelType: IUpdateUserPreferencesVariables["channelType"];
  checked: IUpdateUserPreferencesVariables["checked"];
  listener: (
    result: UpdateResult<
      IUserPreferenceSettings,
      unknown,
      IUpdateUserPreferencesVariables
    >
  ) => void;
  onSuccess?: (settings: IUserPreferenceSettings) => void;
  onError?: (error: unknown) => void;
}
```

## markNotificationsAsRead

Mark a single or multiple notifications as read using the message id.

```typescript theme={null}
headlessService.markNotificationsAsRead({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: ["messageOne", "messageTwo"],
});
```

### method args interface

```typescript theme={null}
interface IMarkNotificationsAsRead {
  messageId: IMessageId;
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## markNotificationsAsSeen

Mark a single or multiple notifications as seen using the message id.

```typescript theme={null}
headlessService.markNotificationsAsSeen({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: ["messageOne", "messageTwo"],
});
```

### method args interface

```
interface IMarkNotificationsAsSeen {
  messageId: IMessageId;
  listener: (result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}

```

## markNotificationsAs

Mark a single or multiple notifications using the message id.

```typescript theme={null}
headlessService.markNotificationsAs({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: ["messageOne", "messageTwo"],
  mark: { seen: true, read: true };
});
```

### method args interface

```typescript theme={null}
interface IMarkNotificationsAs {
  messageId: IMessageId;
  mark: { seen?: boolean; read?: boolean };
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## removeNotification

Removes a single notification using the message id.

```typescript theme={null}
headlessService.removeNotification({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: string }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: "messageOne",
});
```

### method args interface

```typescript theme={null}
interface IRemoveNotification {
  messageId: string;
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: string }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## removeNotifications

<Note>This method is available from version 0.23.1</Note>

Removes multiple notifications using array of message ids (limit of 100).

```typescript theme={null}
headlessService.removeNotifications({
  listener: (
    result: UpdateResult<void, unknown, { messageIds: string[] }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageIds: ["message_id_1", "message_id_2" ],
});
```

### method args interface

```typescript theme={null}
interface IRemoveNotification {
  messageIds: string[];
  listener: (
    result: UpdateResult<void, unknown, { messageIds: string[] }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## removeAllNotifications

Removes all notifications. Can be used to remove all notifications of a feed by passing the `feedId`

```typescript theme={null}
headlessService.removeAllNotifications({
  listener: (result: UpdateResult<void, unknown, undefined>) => {
    console.log(result);
  },
  onSuccess: () => {
    console.log("success");
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  feedId: "feedOne",
});
```

### method args interface

```typescript theme={null}
interface IRemoveAllNotifications {
  feedId?: string;
  listener: (result: UpdateResult<void, unknown, undefined>) => void;
  onSuccess?: () => void;
  onError?: (error: unknown) => void;
}
```

## updateAction

Updates the action button for the notifications.

```typescript theme={null}
headlessService.updateAction({
  listener: (
    result: UpdateResult<IMessage, unknown, IUpdateActionVariables>
  ) => {
    console.log(result);
  },
  onSuccess: (data: IMessage) => {
    console.log(data);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: "messageOne",
  actionButtonType: "primary",
  status: "done",
  payload: {
    abc: "def",
  },
});
```

### method args interface

```typescript theme={null}
interface IUpdateAction {
  messageId: IUpdateActionVariables["messageId"];
  actionButtonType: IUpdateActionVariables["actionButtonType"];
  status: IUpdateActionVariables["status"];
  payload?: IUpdateActionVariables["payload"];
  listener: (
    result: UpdateResult<IMessage, unknown, IUpdateActionVariables>
  ) => void;
  onSuccess?: (data: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## markAllMessagesAsRead

Mark subscriber's all unread messages as read. Can be used to mark all messages as read of a single or multiple feeds by passing the `feedId`

```typescript theme={null}
headlessService.markAllMessagesAsRead({
  listener: (result: UpdateResult<number, unknown, undefined>) => {
    console.log(result);
  },
  onSuccess: (count: number) => {
    console.log(count);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  feedId: ["feedOne", "feedTwo"],
});
```

### method args interface

```typescript theme={null}
interface IMarkAllMessagesAsRead {
  listener: (result: UpdateResult<number, unknown, undefined>) => void;
  onSuccess?: (count: number) => void;
  onError?: (error: unknown) => void;
  feedId?: IFeedId;
}
```

## markAllMessagesAsSeen

Mark subscriber's all unread messages as seen. Can be used to mark all messages as seen of a single or multiple feeds by passing the `feedId`

```typescript theme={null}
headlessService.markAllMessagesAsSeen({
  listener: (result: UpdateResult<number, unknown, undefined>) => {
    console.log(result);
  },
  onSuccess: (count: number) => {
    console.log(count);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  feedId: ["feedOne", "feedTwo"],
});
```

### method args interface

```typescript theme={null}
interface IMarkAllMessagesAsSeen {
  listener: (result: UpdateResult<number, unknown, undefined>) => void;
  onSuccess?: (count: number) => void;
  onError?: (error: unknown) => void;
  feedId?: IFeedId;
}
```

## Types and Interfaces

```typescript theme={null}
interface IHeadlessServiceOptions {
  backendUrl?: string;
  socketUrl?: string;
  applicationIdentifier: string;
  subscriberId?: string;
  subscriberHash?: string;
  config?: {
    retry?: number;
    retryDelay?: number;
  };
}

interface ISession {
  token: string;
  profile: ISubscriberJwt;
}

interface ISubscriberJwt {
  _id: string;
  firstName: string;
  lastName: string;
  email: string;
  subscriberId: string;
  organizationId: string;
  environmentId: string;
  aud: "widget_user";
}

interface IUpdateUserPreferencesVariables {
  templateId: string;
  channelType: string;
  checked: boolean;
}

enum ButtonTypeEnum {
  PRIMARY = "primary",
  SECONDARY = "secondary",
  CLICKED = "clicked",
}

enum MessageActionStatusEnum {
  PENDING = "pending",
  DONE = "done",
}

interface IUpdateActionVariables {
  messageId: string;
  actionButtonType: ButtonTypeEnum;
  status: MessageActionStatusEnum;
  payload?: Record<string, unknown>;
}

type FetchResult<T = unknown> = Pick<
  QueryObserverResult<T>,
  "data" | "error" | "status" | "isLoading" | "isFetching" | "isError"
>;

type UpdateResult<
  TData = unknown,
  TError = unknown,
  TVariables = unknown
> = Pick<
  MutationObserverResult<TData, TError, TVariables>,
  "data" | "error" | "status" | "isLoading" | "isError"
>;

type IMessageId = string | string[];
type IFeedId = string | string[];
```

<Tip>
  QueryObserverResult and MutationObserverResult are imported from
  the `@tanstack/query-core` library.
</Tip>


# Security and Compliance
Source: https://v0.x-docs.novu.co/security-and-compliance/security

Common questions related to security, compliance, privacy policy and terms and conditions

### What should I do if I have regulatory or security issues with PII?

We regularly work with big companies and are happy to help and support you with guidance, and various compliances including reports to ease your security and legal team. If you have concerns about PII, you can use our OS version, Novu Hybrid-Cloud enterprise plan, or reach out to us at [sales@novu.co](mailto:sales@novu.co), [support@novu.co](mailto:support@novu.co), or Discord.

### I need my data to reside in the EU, can it be done?

Yes, as part of our GDPR compliance we have our cloud version available on both EU (Frankfurt), as well as US (Virginia).

### Are you GDPR compliant?

Yes, you can see the complete compliance report on our [security page](https://trust.novu.co/). Novu also decided to take the extra step and provide separate data residency in both the EU and the US.

### I created my account in the EU/US, can I switch to the other one?

Not exactly, to keep data residency intact we cannot simply copy or move data between data warehouses across US and EU. However if you have the need please contact us at [sales@novu.co](mailto:sales@novu.co)

### Are you SOC 2 compliant?

Yes, Novu Cloud is SOC 2 Type II compliant, we have made sure to do penetration tests, security training, evidence collection, and SDL. You can see live control updated on our [security page](https://trust.novu.co/), and ask for our security report as well at [sales@novu.co](mailto:sales@novu.co).

### Are you ISO 27001 compliant?

Yes, Novu Cloud is ISO27001 compliant, we have made sure to go through both Stage 1 and Stage 2 audits, and fully define ISMS requirements. From entirely creating our organization processes, defining organization risk assessment policies, and building organization Incident Response & Disaster Recovery plans.

### Where is my data stored?

Based on the selected solution there are a couple of options. On the OS option based on where you choose to store it :) As to the Novu Cloud solution, you can choose the EU (Frankfurt) or the US (Virginia). In case you are working on the Novu Hybrid-Cloud solution we will help you deploy your data inside your select network.

### For how long user data is stored?

By default, data is stored using the following TTL values

* Notifications (for 1 month)
* Jobs (for 1 month)
* Message (for in-app messages - 12 months, for all other messages - 1 month)
* Execution Details (for 1 month)
* Subscribers, Workflows, Feeds, Layouts (Not deleted automatically, can be deleted by the user at any time)

If you want to delete any specific data or information, reach out to us at [support@novu.co](mailto:support@novu.co)

### How to report any vulnerability or security issue?

We are equally committed to our users and their data’s security. We highly appreciate it if someone shares security vulnerabilities with us. Feel free to use the [github issue](https://github.com/novuhq/novu/security/advisories/new) or email us at [security@novu.co](mailto:security@novu.co).


# AWS
Source: https://v0.x-docs.novu.co/self-hosting-novu/aws

Learn how to deploy Novu to AWS

Amazon Web Services (AWS) is a cloud computing platform by Amazon, providing a wide range of on-demand services like computing power, storage, and databases over the internet.
It enables businesses and individuals to avoid managing physical infrastructure and offers features for computing, storage, databases, analytics, machine learning, and more.
AWS is known for its scalability, flexibility, and global network of data centers.
Learn more about [AWS](https://docs.aws.amazon.com/)

## Deploying on EC2 with the Docker Compose File

Deploying Novu on EC2 with Docker Compose involves several steps.

In general, the steps are as follows:

1. **Set up an EC2 Instance**: Create an instance on AWS EC2. We reccomend a bare minimum of 4 CPU Cores and 16GB of RAM.
2. **Install Docker**: Once you have your instance up and running, SSH into it and install Docker. You can do this by running the following commands:

```bash theme={null}
sudo yum update -y sudo amazon-linux-extras install docker;
sudo service docker start sudo usermod -a -G docker
ec2-user
```

3. **Install Docker Compose**: Docker Compose will allow you to easily manage your application which will consist of multiple Docker containers.
   Install it by running:

```bash theme={null}
sudo curl -L "https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose;
sudo chmod +x /usr/local/bin/docker-compose
```

4. **Deploy Novu**: Now, clone the Novu repository and navigate to the directory containing the docker-compose.yml file.
   To start your Novu instance, simply run:

```bash theme={null}
docker-compose up -d
```

Please note, there are user reports indicating an issue with volume persistence when deploying Novu on EC2 with Docker Compose.
You can see the discussions about this problem [here](https://github.com/novuhq/novu/issues/3339) as we do not provide official support for these types of deployments.
This is something to be aware of when deploying in this manner, and you may need to adopt additional strategies for data persistence.
Be sure to consult the Novu documentation as well as any relevant EC2 and Docker documentation for any necessary details related to your specific deployment needs.
Additionally, keep in mind that these general steps may not cover all nuances or requirements of your particular use case or the specific configuration of the Novu application.
Always ensure any deployment follows best practices for security, scalability, and maintainability.

# 🏗️ This page is still in creation process

We believe in the power of collaboration. If you have insights to share or would like to contribute to the development of this page, we welcome your input. To get involved, follow these steps:

**Open an Issue:** If you've identified an area for improvement or have a suggestion, start by opening an issue in our repository. This allows us to track and discuss the proposed changes.

**Create a Pull Request (PR):** Once you're ready to contribute, fork our repository and create a branch. Implement your changes within this branch and submit a pull request to our **Staging branch**.

By following these steps, you're helping us enhance the quality and depth of our resources. We appreciate your effort in making this page an even more valuable asset.

Your contributions drive progress. Let's build together!


# Deploy with Docker
Source: https://v0.x-docs.novu.co/self-hosting-novu/deploy-with-docker

Learn how to deploy Novu with Docker

Docker compose is the easiest way to get started with self-hosted Novu.

## Before you begin

You need the following installed in your system:

* [Docker](https://docs.docker.com/engine/install/) and [docker-compose](https://docs.docker.com/compose/install/)
* [Git](https://git-scm.com/downloads)

<iframe />

<Info>In above loom video `local/deployment` directory is used. Now it has been moved to `docker/community`. Follow below mentioned steps.</Info>

## Quick Start

### Get the code

Clone the Novu repo and enter the docker directory locally:

```bash theme={null}
# Get the code
git clone --depth 1 https://github.com/novuhq/novu

# Go to the docker community folder
cd novu/docker/community

# Copy the example env file
cp .env.example .env

# Start Novu
docker-compose -f docker-compose.yml up
```

Now visit [http://localhost:4200](http://localhost:4200/) to start using Novu.

## Securing your setup

While we provide you with some example secrets for getting started, you should NEVER deploy your Novu setup using the defaults provided.

Update the `.env` file with your own secrets.

### Required Variables:

* `JWT_SECRET`: Used by the API to generate JWT keys.
* `STORE_ENCRYPTION_KEY`: Used to encrypt/decrypt the provider credentials. It must be 32 characters long.
* `HOST_NAME`: Host name of your installation. This will be the base URL of your installation. For example, if you are deploying to server with ip `35.154.137.80`, then you should set this to `http://35.154.137.80`.

`REDIS_CACHE_SERVICE_HOST` and `REDIS_HOST` can have same value for small deployments. For larger deployments, it is recommended to use separate Redis instances for caching and queue management.

## Configuration

To keep the setup simple, we made some choices that may not be optimal for production:

* the database is in the same machine as the servers
* the storage uses localstack instead of S3

We strongly recommend that you decouple your database before deploying.

### Triggering events with custom installation

When self-hosting Novu, in order to trigger an event you must first create a new `Novu` object and configure it with the proper `backendUrl`.

```tsx theme={null}
import { Novu } from '@novu/node';

const config = {
  backendUrl: '<REPLACE_WITH_BACKEND_URL>',
};

const novu = new Novu('<API_KEY>', config);

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {},
});
```

### Pointing IFrame embed to custom installation

When using the IFrame embed to attach the notification center rather than the React component, you need to specify the `backendUrl` and the `socketUrl` when initializing the iframe.

```html theme={null}
<script>
  novu.init(
    '<REPLACE_APPLICATION_ID>',
    {
      unseenBadgeSelector: '#unseen-badge',
      bellSelector: '#notification-bell',
      backendUrl: 'https://api.example.com',
      socketUrl: 'https://ws.example.com',
    },
    {}
  );
</script>

```

### Using React Component with custom installation

See [Use your own backend and socket URL](https://docs.novu.co/notification-center/react/react-components#use-your-own-backend-and-socket-url).

### Caching

We are introducing the first stage of caching in our system to improve performance and efficiency. Caching is turned off by default, but can easily be activated by setting the following environment variables:

* REDIS\_CACHE\_SERVICE\_HOST
* REDIS\_CACHE\_SERVICE\_PORT

Currently, we are caching data in the most heavily loaded areas of the system: the widget requests such as feed and unseen count, as well as common DAL requests during the execution of trigger event flow. These are the most heavily used areas of our system, and we hope that by implementing caching in these areas, we can improve performance in the near future.

### Reverse-Proxy / Load Balancers

To implement a reverse-proxy or load balancer in front of Novu, you need to set the GLOBAL\_CONTEXT\_PATH for the base path of the application.
This is the path that the application will be served from after the domain.
For example:

* company.com/novu
  This is used to set the base path for the application, and is used to set the base path for the API, web, and websocket connections.

The following environment variables are used to set the context path for each public service that Novu provides:
API\_CONTEXT\_PATH
WIDGET\_CONTEXT\_PATH
WS\_CONTEXT\_PATH
WEB\_CONTEXT\_PATH

These allow you to set the context path for each service independently or dependently of the GLOBAL\_CONTEXT\_PATH.

For example, if I was using a reverse proxy to serve Novu from company.com/novu,
I would set the GLOBAL\_CONTEXT\_PATH to novu,
and then set the API\_CONTEXT\_PATH to api,
the WIDGET\_CONTEXT\_PATH to widget,
the WS\_CONTEXT\_PATH to ws,
and the WEB\_CONTEXT\_PATH to web.

This would produce the following urls:

* API: company.com/novu/api
* WIDGET: company.com/novu/widget
* WS: company.com/novu/ws
* WEB: company.com/novu/web

However the Service context path can be used entirely independently of the GLOBAL\_CONTEXT\_PATH.

For example, if I wanted to expose the api as novu-api, I would set the API\_CONTEXT\_PATH to novu-api without setting the GLOBAL\_CONTEXT\_PATH.
This would producte the following url:

* API: company.com/novu-api

<Note> These env variables should be present on all services novu provides due to tight coupling.</Note>


# Introduction
Source: https://v0.x-docs.novu.co/self-hosting-novu/introduction



Self-hosting Novu involves setting up and maintaining your communication infrastructure using your own servers.
While this offers full control and customization,
some features which are available only for Novu’s cloud-managed won't be available in a self-hosted environment.

## Minimum System Requirements

For basic installation, a server with 16GB RAM and 8 CPUs is fine. However, specifications vary depending on requirements and here are sample specifications for handling 1M plus notifications:

* If everything is running on one machine, then at least 36 vCPU and 64GB of RAM.
* If services are running across containers, then it is recommended to run 3 containers per service, each container having 2 vCPU and 4GB of RAM.
* If you're using Kubernetes, then the K8 system needs to have 36 vCPU and 64GB of RAM at least in the cluster to run the servers.
* On AWS, a c6g.8xlarge instance with 32 vCPU and 64GB of RAM.
* In all cases, you need to also have 2 Redis clusters with the queue one having an Append only log file active (AOL) to prevent instances of job loss during an outage,  a MongoDB cluster equivalent to a M20 or greater on Atlas, and 10GB of S3 storage.
* Lastly, the queue Redis instance should be 8GB MINIMUM as there needs to be enough space to handle spikes in notifications or the whole system will brick.

<Note>Note that these specifications are subject to your requirements, the scale of your operations, and should be adjusted as needed.</Note>
<Warning>Github login is not available in self-hosting. If you're self hosting Novu, use your email and password to log into your Novu account!</Warning>


# Kubernetes
Source: https://v0.x-docs.novu.co/self-hosting-novu/kubernetes

Learn how to deploy Novu with K8s

<Warning>
  We do not plan to support any official public kubernetes deployment at this time.
  This guide is to help assist advanced users who want to deploy Novu on their own kubernetes cluster.
</Warning>

Kubernetes is an open-source platform that automates the deployment, scaling, and management of containerized applications.

You can find a community driven [helm deployment](https://github.com/novuhq/novu/blob/next/docker/kubernetes/helm/README.md) in our repository.

## Novu Web Container Does not Run on Kubernetes

Due to the way we build our web container image,
you will need to build your own image and push it to your own registry.
This is due to us compiling the frontend when the container starts.

You can follow our [dev-deploy-web workflow](https://github.com/novuhq/novu/blob/next/.github/workflows/dev-deploy-web.yml)
to see how we build our web container image.
You can also use this workflow to build your own image, you will just need to remove all of the steps after the deploy to netlify step.

<Note>
  Only need to do this IF you do not allow root only access on your cluster.
</Note>


# Object Storage (S3, Blob, GCS)
Source: https://v0.x-docs.novu.co/self-hosting-novu/object-storage

Using S3 as a storage backend for your application

For local development we use [LocalStack.cloud](https://localstack.cloud/). It is utilized as a local emulation of S3 during development.

This might be beneficial for testing and development purposes before transitioning to actual S3 service like in a production environment.

## AWS S3

### Configuration

AWS S3 requires the following environment variables to be set:

1. S3\_REGION:
2. S3\_LOCAL\_STACK (optional): S3 endpoint to connect to, leave blank if your connecting directly to AWS
3. S3\_BUCKET\_NAME: Name of the bucket to use
4. STORAGE\_SERVICE: Name of the storage service to use, 'AWS' or 'LOCALSTACK' for S3.

### Bucket Configuration

In general, access to the S3 bucket is very permissive.

The following process is used to manage access to the S3 bucket.

General design:

* public read access (for logo and email attachments—all data is open for read to anyone)
* write access is via pre-signed url (client-side PUT to S3 after server-side request)
* private write access (get, put, delete)
* objects are written with organisationIdTenancy/objectId (at least for brand logos)

Specifics for access:

* CORS access on bucket (this is documented)
* bucket object do not need versioning (as all uploads are deemed unique)
* ACL on buckets is 'public-read' (as part of the pre-signed URLs)
* image uploads (as pre-signed) could also have rules to limit (DENY policy) on extension types (although UI also does this but leaves open a vector)
* AWS (specific): ensure that Allow owenership controls is 'BucketOwnerPreferred' to allow ACL access (rather than role/user) (ie PutObjectAcl)

### Example Terraform

```terraform theme={null}
/**
 * This sets up an S3 bucket for notifications assets (eg photos, documents). The bucket is
 * PUBLIC for read access and needs to be opened up to the API (which is deployed as an ECS task).
 *
 * It also needs to be opened up to worker (to create pre-signed urls for uploads)
 *
 * This bucket is:
 *  * public read access
 *  * private write access to the credentials (added onto the user rather than onto the bucket)
 */

#
# WARNING: this bucket uses IAM Policies and ACL for access
#
#  - @see https://binaryguy.tech/aws/s3/iam-policies-vs-s3-policies-vs-s3-bucket-acls/#:~:text=The%20biggest%20advantage%20of%20using,well%20as%20objects%20in%20it.
#  - @see https://aws.amazon.com/blogs/security/iam-policies-and-bucket-policies-and-acls-oh-my-controlling-access-to-s3-resources/
#  - @see https://stackoverflow.com/questions/47815526/s3-bucket-policy-vs-access-control-list
#
#
# TF: https://www.terraform.io/docs/providers/aws/r/s3_bucket.html
# AWS: http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/s3api/create-bucket.html
resource "aws_s3_bucket" "notifications" {
  bucket = "${var.environment}-notifications-data"
  # removed for upgrade to aws provider 4.0
  # see https://registry.terraform.io/providers/hashicorp/aws/latest/docs/guides/version-4-upgrade#acl-argument
  # acl    = "private"

  tags = {
    Environment = var.environment
    Terraform   = true
  }
}


# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_public_access_block
resource "aws_s3_bucket_public_access_block" "notifications" {
  bucket                  = aws_s3_bucket.notifications.id
  block_public_acls       = false
  # This feature protects your bucket from accidentally getting a policy that would enable public access
  # We WANT public access for read
  block_public_policy     = false
  ignore_public_acls      = false
  restrict_public_buckets = false
}


# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_ownership_controls
# this is required when setting the 'public-read' acl—without it it fails on apply
resource "aws_s3_bucket_ownership_controls" "notifications" {
  bucket = aws_s3_bucket.notifications.id

  rule {
    object_ownership = "BucketOwnerPreferred"
  }
}

# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_acl
resource "aws_s3_bucket_acl" "notifications" {
  bucket = aws_s3_bucket.notifications.id
  # Defaults to private
  # ["private" "public-read" "public-read-write" "authenticated-read" "aws-exec-read" "log-delivery-write"]
  acl    = "public-read"

  depends_on = [
    aws_s3_bucket_ownership_controls.notifications,
    aws_s3_bucket_public_access_block.notifications,
  ]
}

#
# Note: no point on having vesrioning enabled
#

#
# Restricted CORS policy but increased headers exposed (that could be further restrictred)
#
# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_cors_configuration
# AWS: https://docs.amplify.aws/lib/storage/getting-started/q/platform/js/#amazon-s3-bucket-cors-policy-setup
resource "aws_s3_bucket_cors_configuration" "notifications" {
  bucket = aws_s3_bucket.notifications.id

  cors_rule {
    allowed_headers = ["*"]
    allowed_methods = [
      "GET",
      "HEAD",
      "PUT",
    ]
    allowed_origins = ["/* OWN FQDN */"]
    expose_headers  = [
      "x-amz-server-side-encryption",
      "x-amz-request-id",
      "x-amz-id-2",
      "x-amz-meta-tag",
      "ETag"
    ]
    max_age_seconds = 3000
  }
}

resource "aws_s3_bucket_policy" "notifications" {
  bucket = aws_s3_bucket.notifications.id
  policy = data.aws_iam_policy_document.notifications-user.json
}

# [Data] IAM policy to define S3 permissions
#
# Restricting users files types to avoid problems (note: hand helds love to upload PDFs)
#
# TF: https://www.terraform.io/docs/providers/aws/d/iam_policy_document.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html
data "aws_iam_policy_document" "notifications-user" {
  statement {
    sid    = "DenyNonImage"
    effect = "Deny"
    principals {
      identifiers = [aws_iam_user.notifications.arn]
      type        = "AWS"
    }
    actions = [
      # NOTE: this is an ACL permissions
      "s3:PutObjectAcl",
    ]
    not_resources = [
      "${aws_s3_bucket.notifications.arn}/*.png",
      "${aws_s3_bucket.notifications.arn}/*.jpg",
      "${aws_s3_bucket.notifications.arn}/*.jpeg",
      "${aws_s3_bucket.notifications.arn}/*.gif"
    ]
  }
  # NOTE: these rules exist on the user policy
/*
  statement {
    effect = "Allow"
    principals {
      type        = "AWS"
      identifiers = [aws_iam_user.notifications.arn]
    }
    actions = [
      "s3:GetObject",
      "s3:DeleteObject",
      "s3:ListBucket",
      "s3:PutObject",
      # this is the magic spice, because the perms are created via ACL (rather than roles)
      "s3:PutObjectAcl"
    ]
    resources = [
      "${aws_s3_bucket.notifications.arn}*/
/*",
    ]
  }
*/
}

#######################

# TF: https://www.terraform.io/docs/providers/aws/r/iam_policy.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html
resource "aws_iam_policy" "s3" {
  name        = "ecs-app-${var.environment}-s3"
  description = "Access from the ecs tasks to s3 buckets"
  policy      = data.aws_iam_policy_document.s3.json
}

# [Data] IAM policy to define S3 permissions
# TF: https://www.terraform.io/docs/providers/aws/d/iam_policy_document.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html
data "aws_iam_policy_document" "s3" {
  statement {
    sid     = ""
    effect  = "Allow"
    actions = [
      "s3:DeleteObject",
      "s3:GetObject",
      "s3:PutObject",
      # this is the magic spice, because the perms are created via ACL (rather than roles)
      "s3:PutObjectAcl",
      "s3:ListBucket"
    ]
    resources = [
      "arn:aws:s3:::${var.assets_bucket}/*"
    ]
  }
}

######################

# Attaches a managed IAM policy to an IAM role for the ecs tasks
# TF: https://www.terraform.io/docs/providers/aws/r/iam_role_policy_attachment.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html
resource "aws_iam_role_policy_attachment" "s3" {
  role       = aws_iam_role.app_task.name  # need your role attached to whatever is doing the execution (eg workload task)
  policy_arn = aws_iam_policy.s3.arn
}
```

## Azure Blob Storage Configuration

### Configuration

Azure Blob Storage requires the following environment variables to be set:

### Required

1. STORAGE\_SERVICE: Name of the storage service to use, 'AZURE' Azure Blob.
2. AZURE\_CONTAINER\_NAME: The name of the container in your Azure Storage account that you wish to use for your blob storage.
3. AZURE\_ACCOUNT\_NAME: The name of your Azure Storage account. This is used to form the URL at which your blob storage is accessible.
4. AZURE\_ACCOUNT\_KEY: The access key for your Azure Storage account. This is used to authenticate requests made against your blob storage.
5. AZURE\_HOST\_NAME: The host name of your Azure Storage account . This is used to form the URL at which your blob storage is accessible. [Ref](https://learn.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-nodejs?tabs=managed-identity%2Croles-azure-portal%2Csign-in-azure-cli#upload-blobs-to-a-container).

### Bucket Configuration

TBD

## Google Cloud Storage Configuration

### Configuration

Google Cloud Storage requires the following environment variables to be set:

1. `GCS_BUCKET_NAME`: Name of the bucket to use.
2. `GOOGLE_APPLICATION_CREDENTIALS`: Path to the service account key file.
3. `STORAGE_SERVICE`: Name of the storage service to use, 'GCS' for Google Cloud Storage.

### Bucket Configuration

TBD


# Broadcast event to all
Source: https://v0.x-docs.novu.co/api-reference/events/broadcast-event-to-all

post /v1/events/trigger/broadcast
Trigger a broadcast event to all existing subscribers, could be used to send announcements, etc.
      In the future could be used to trigger events to a subset of subscribers based on defined filters.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.events.broadcast("<WORKFLOW_TRIGGER_IDENTIFIER>", {
    payload: {
      customKey: "customValue",
      customKey1: {
        nestedkey1: "nestedValue1"
      }
    },
    overrides: {
      email: {
        from: "support@novu.co"
      }
    },
    tenant: "tenantIdentifier"
  })
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->broadcastEvent([
      'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
      'payload' => ['customVariables' => 'Hello'],
      'transactionId' => '<REPLACE_WITH_TRANSACTION_ID>'
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'name' => 'Trigger',
      'payload' => {
          'first-name' => 'Adam',
          'last-name' => 'Eve'
      },
      'transactionId' => 'sw900999as' #optional
  }
  client.broadcast_event(payload)
  ```

  ```bash cURL theme={null}
  curl -X POST https://api.novu.co/v1/events/trigger/broadcast \
    -H "Authorization: ApiKey <NOVU_API_KEY>" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "<WORKFLOW_TRIGGER_IDENTIFIER>",
      "payload": {
        "customKey": "customValue",
        "customKey1": {
          "nestedkey1": "nestedValue1"
        }
      },
      "overrides": {
        "email": {
          "from": "support@novu.co"
        }
      },
      "tenant": "tenantIdentifier"
    }'
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
  	apiKey := "<NOVU_API_KEY>"
  	ctx := context.Background()

  	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

      name := interface{}{"<WORKFLOW_TRIGGER_IDENTIFIER>"}

  	payload := map[string]interface{}{
  		"name": "Hello World",
  		"organization": map[string]interface{}{
  			"logo": "https://happycorp.com/logo.png",
  		},
  	}

      data := novu.BroadcastEventToAll{Name: name, Payload: payload}

  	resp, err := novuClient.EventApi.BroadcastToAll(ctx, data)

  	if err != nil {
  		log.Fatal("novu error", err.Error())
  		return
  	}
  }
  ```

  ```python Python theme={null}
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  novu = EventApi(url, api_key).broadcast(
      name="<WORKFLOW_TRIGGER_IDENTIFIER>",
      payload={"customVariable": "value"},  # Optional
  )
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.events.requests.TriggerEventRequest;
  import co.novu.api.events.responses.TriggerEventResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest = new SubscriberRequest();
          subscriberRequest.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest.setFirstName("<FIRST_NAME>");
          subscriberRequest.setLastName("<LAST_NAME>");
          subscriberRequest.setPhone("<PHONE_NUMBER>");
          subscriberRequest.setAvatar("<AVATAR>");
          subscriberRequest.setSubscriberId("<SUBSCRIBER_ID>");

          TriggerEventRequest triggerEventRequest = new TriggerEventRequest();
          triggerEventRequest.setName("<NAME>"); 
          triggerEventRequest.setTo(subscriberRequest);
          triggerEventRequest.setPayload(Collections.singletonMap("<CUSTOM_VARIABLE_NAME>", "<CUSTOM_VARIABLE_VALUE>"));

          TriggerEventResponse response = novu.broadcastEvent(triggerEventRequest);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var testRecord = new TestRecord
  {
      Message = "This is a test message"
  };

  var dto = new EventTriggerDataDto()
  {
      EventName = "<WORKFLOW_TRIGGER_IDENTIFIER>",
      To =
      {
          SubscriberId = "<UNIQUE_SUBSCRIBER_IDENTIFIER>"
      },
      Payload = testRecord
  };

  var trigger = await novu.Event.TriggerBroadcastAsync(dto);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "acknowledged": true,
          "status": "processed",
          "transactionId": "string"
      }
  }
  ```
</ResponseExample>


# Bulk trigger event
Source: https://v0.x-docs.novu.co/api-reference/events/bulk-trigger-event

post /v1/events/trigger/bulk

      Using this endpoint you can trigger multiple events at once, to avoid multiple calls to the API.
      The bulk API is limited to 100 events per request.
    

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.events.bulkTrigger([
    {
      name: "<WORKFLOW_TRIGGER_IDENTIFIER>",
      to: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload: {
        customKey: "customValue",
        customKey1: {
          nestedkey1: "nestedValue1"
        }
      },
      overrides: {
        email: {
          from: "support@novu.co"
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    },
    {
      name: "<WORKFLOW_TRIGGER_IDENTIFIER>",
      to: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload: {
        customKey: "customValue",
        customKey1: {
          nestedkey1: "nestedValue1"
        }
      },
      overrides: {
        email: {
          from: "support@novu.co"
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    }
  ])
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->bulkTriggerEvent([
      [
          'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>', 
          'to' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>', 
          'payload' => ['customVariables' => 'Hello']
      ],
      [
          'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>', 
          'to' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>', 
          'payload' => ['customVariables' => 'World']
      ],
  ])->toArray();
  ```

  ```bash cURL theme={null}

  curl -X POST https://api.novu.co/v1/events/trigger/bulk \
    -H "Authorization: ApiKey <NOVU_API_KEY>" \
    -H "Content-Type: application/json" \
    -d '{
      "events": [
        {
          "name": "<WORKFLOW_TRIGGER_IDENTIFIER>",
          "to": {
            "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
            "email": "john@doemail.com"
          },
          "payload": {
            "customKey": "customValue",
            "customKey1": {
              "nestedkey1": "nestedValue1"
            }
          },
          "overrides": {
            "email": {
              "from": "support@novu.co"
            }
          },
          "actor": "actorId",
          "tenant": "tenantIdentifier"
        },
        {
          "name": "<WORKFLOW_TRIGGER_IDENTIFIER>",
          "to": {
            "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
            "email": "janet@doemail.com"
          },
          "payload": {
            "customKey": "customValue",
            "customKey1": {
              "nestedkey1": "nestedValue1"
            }
          },
          "overrides": {
            "email": {
              "from": "support@novu.co"
            }
          },
          "actor": "actorId",
          "tenant": "tenantIdentifier"
        }
      ]
    }'


  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'events' => [
          {
              'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
              'payload' => { # optional
                  'first-name' => 'Adam' # optional
              },
              'to' => {
                  'subscriberId' => '7789'
              },
              'transactionId' => '89kjfke9893' #optional
          },
          {
              'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
              'payload' => { # optional
                  'last-name' => 'Eve' # optional
              },
              'to' => {
                  'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
              },
              'transactionId' => 'sw900999as' #optional
          }
      ]
  }
  client.trigger_bulk_event(payload)
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
  	apiKey := "<NOVU_API_KEY>"
  	ctx := context.Background()

  	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

      event1 := novu.BulkTriggerOptions{
          Name: []string{"<WORKFLOW_TRIGGER_IDENTIFIER>"},
          To: map[string]interface{}{
              "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
              "email":        "john@doemail.com",
  	    },
          Payload: map[string]interface{}{
              "name": "Hello World",
              "organization": map[string]interface{}{
                  "logo": "https://happycorp.com/logo.png",
              },
  	    }
      }
      event2 := novu.BulkTriggerOptions{
          Name: []string{"<WORKFLOW_TRIGGER_IDENTIFIER>"},
          To: map[string]interface{}{
              "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
              "email":        "janet@doemail.com",
  	    },
          Payload: map[string]interface{}{
              "name": "Hello World",
              "organization": map[string]interface{}{
                  "logo": "https://happycorp.com/logo.png",
              },
  	    }
      }

      triggerPayload := []novu.BulkTriggerOptions{ event1, event2}

  	resp, err := novuClient.EventApi.TriggerBulk(ctx, triggerPayload)

  	if err != nil {
  		log.Fatal("novu error", err.Error())
  		return
  	}
  }
  ```

  ```python Python theme={null}
  from novu.dto.event import InputEventDto
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  event_1 = InputEventDto(
      name="<WORKFLOW_TRIGGER_IDENTIFIER>",  # The workflow ID is the slug of the workflow name. It can be found on the workflow page.
      recipients="<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload={},  # Your custom Novu payload goes here
  )
  event_2 = InputEventDto(
      name="<WORKFLOW_TRIGGER_IDENTIFIER>",
      recipients="<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload={},
  )

  novu = EventApi(url, api_key).trigger_bulk(
      events=[event1,event2]
  )
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.events.requests.TriggerEventRequest;
  import co.novu.api.events.pojos.BulkTriggerEventRequest;
  import co.novu.api.events.responses.BulkTriggerEventResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest = new SubscriberRequest();
          subscriberRequest.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest.setFirstName("<FIRST_NAME>");
          subscriberRequest.setLastName("<LAST_NAME>");
          subscriberRequest.setPhone("<PHONE_NUMBER>");
          subscriberRequest.setAvatar("<AVATAR>");
          subscriberRequest.setSubscriberId("<SUBSCRIBER_ID>");

          TriggerEventRequest triggerEventRequest1 = new TriggerEventRequest();
          triggerEventRequest1.setName("<NAME>");
          triggerEventRequest1.setTo(subscriberRequest);
          triggerEventRequest1.setPayload(Collections.singletonMap("<CUSTOM_VARIABLE_NAME>", "<CUSTOM_VARIABLE_VALUE>"));
          
          TriggerEventRequest triggerEventRequest2 = new TriggerEventRequest();
          triggerEventRequest2.setName("<NAME>");
          triggerEventRequest2.setTo(subscriberRequest);
          triggerEventRequest2.setPayload(Collections.singletonMap("<CUSTOM_VARIABLE_NAME>", "<CUSTOM_VARIABLE_VALUE>"));

          BulkTriggerEventRequest bulkTriggerEventRequest = new BulkTriggerEventRequest();
          bulkTriggerEventRequest.setEvents(Arrays.asList(triggerEventRequest1, triggerEventRequest2));

          BulkTriggerEventResponse response = novu.bulkTriggerEvent(bulkTriggerEventRequest);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var payload = new List<EventTriggerDataDto>()
  {
      new()
      {
          EventName = "<WORKFLOW_TRIGGER_IDENTIFIER>",
          To = { SubscriberId = "<UNIQUE_SUBSCRIBER_IDENTIFIER>"},
          Payload = new TestRecord(){ Message = "Hello"}
      },
      new()
      {
          EventName = "<WORKFLOW_TRIGGER_IDENTIFIER>",
          To = { SubscriberId = "<UNIQUE_SUBSCRIBER_IDENTIFIER>"},
          Payload = new TestRecord(){ Message = "World"}
      },
  };

  var trigger = await novu.Event.TriggerBulkAsync(payload);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": [
          {
              "acknowledged": true,
              "status": "processed",
              "transactionId": "string"
          }
      ]
  }
  ```
</ResponseExample>


# Cancel triggered event
Source: https://v0.x-docs.novu.co/api-reference/events/cancel-triggered-event

delete /v1/events/trigger/{transactionId}

    Using a previously generated transactionId during the event trigger,
     will cancel any active or pending workflows. This is useful to cancel active digests, delays etc...
    

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<Info> If `false` value is returned in response, it means that event has already been completed its execution or cancelled before. Already completed event can not be cancelled. If `true` value is returned in response, then it means that event execution has been cancelled successfully. Any digest or delay step with pending exection will also be cancelled.</Info>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.events.cancel("transactionId");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $transactionId = "transactionId";

  $novu->cancelEvent($transactionId);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.cancel_triggered_event('transactionId')
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
  	apiKey := "<NOVU_API_KEY>"
  	ctx := context.Background()

  	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

      transactionId := "<transaction_id>";

  	resp, err := novuClient.EventApi.CancelTrigger(ctx, transactionId)

  	if err != nil {
  		log.Fatal("novu error", err.Error())
  		return
  	}
  }
  ```

  ```bash cURL theme={null}

  curl --request DELETE \
    --url https://api.novu.co/v1/events/trigger/<transaction_id> \
    --header 'Authorization: ApiKey <NOVU_API_KEY>'

  ```

  ```python Python theme={null}
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  novu = EventApi(url, api_key).delete("transactionId");
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.events.responses.CancelEventResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);

          String transactionId = "<REPLACE_WITH_TRANSACTION_ID>";

          CancelEventResponse response = novu.cancelTriggeredEvent(transactionId);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var cancelled = await novu.Event.TriggerCancelAsync("triggerTransactionId");
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  { 
    data: true
  }
  ```
</ResponseExample>


# Trigger event
Source: https://v0.x-docs.novu.co/api-reference/events/trigger-event

post /v1/events/trigger

    Trigger event is the main (and only) way to send notifications to subscribers. The trigger identifier is used to match the particular workflow associated with it. Maximum number of recipients can be 100. Additional information can be passed according the body interface below.
    To prevent duplicate triggers, you can optionally pass a **transactionId** in the request body. If the same **transactionId** is used again, the trigger will be ignored. The retention period depends on your billing tier.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
    {
      to: {
        subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
        email: 'john@doemail.com',
        firstName: 'John',
        lastName: 'Doe',
      },
      payload: {
        name: "Hello World",
        organization: {
          logo: 'https://happycorp.com/logo.png',
        },
      },
    }
  );
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->triggerEvent([
      'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
      'payload' => ['customVariables' => 'Hello'],
      'to' => [
          'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          'phone' => '07983882186'
      ]
  ])->toArray();
  ```

  ```bash cURL theme={null}

  curl -X POST https://api.novu.co/v1/events/trigger \
    -H "Authorization: ApiKey <NOVU_API_KEY>" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "<WORKFLOW_TRIGGER_IDENTIFIER>",
      "to": {
        "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
        "email": "john@doemail.com",
        "firstName": "John",
        "lastName": "Doe"
      },
      "payload": {
        "name": "Hello World",
        "organization": {
          "logo": "https://happycorp.com/logo.png"
        }
      }
    }'
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
      'payload' => { # optional
          'first-name' => 'Adam' # optional
      },
      'to' => {
          'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
      },
      'transactionId' => '89kjfke9893' #optional
  }

  client.trigger_event(payload)
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
  	subscriberID := "<UNIQUE_SUBSCRIBER_IDENTIFIER>"
  	apiKey := "<NOVU_API_KEY>"
  	eventId := "<WORKFLOW_TRIGGER_IDENTIFIER>"

  	ctx := context.Background()
  	to := map[string]interface{}{
  		"lastName":     "Doe",
  		"firstName":    "John",
  		"subscriberId": subscriberID,
  		"email":        "john@doemail.com",
  	}

  	payload := map[string]interface{}{
  		"name": "Hello World",
  		"organization": map[string]interface{}{
  			"logo": "https://happycorp.com/logo.png",
  		},
  	}

  	data := novu.ITriggerPayloadOptions{To: to, Payload: payload}
  	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

  	resp, err := novuClient.EventApi.Trigger(ctx, eventId, data)

  	if err != nil {
  		log.Fatal("novu error", err.Error())
  		return
  	}
  }
  ```

  ```python Python theme={null}
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  novu = EventApi(url, api_key).trigger(
      name="<WORKFLOW_TRIGGER_IDENTIFIER>",  # This is the Workflow ID. It can be found on the workflow page.
      recipients="<UNIQUE_SUBSCRIBER_IDENTIFIER>", # The subscriber ID can be gotten from the dashboard.
      payload={},  # Your custom Novu payload goes here
  )
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.events.requests.TriggerEventRequest;
  import co.novu.api.events.responses.TriggerEventResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest = new SubscriberRequest();
          subscriberRequest.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest.setFirstName("<FIRST_NAME>");
          subscriberRequest.setLastName("<LAST_NAME>");
          subscriberRequest.setPhone("<PHONE_NUMBER>");
          subscriberRequest.setAvatar("<AVATAR>");
          subscriberRequest.setSubscriberId("<SUBSCRIBER_ID>");

          TriggerEventRequest triggerEventRequest = new TriggerEventRequest();
          triggerEventRequest.setName("<NAME>");
          triggerEventRequest.setTo(subscriberRequest);
          triggerEventRequest.setPayload(Collections.singletonMap("<CUSTOM_VARIABLE_NAME>", "<CUSTOM_VARIABLE_VALUE>"));
          
          TriggerEventResponse response = novu.triggerEvent(triggerEventRequest);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  public class OnboardEventPayload
  {
    [JsonProperty("username")]
    public string Username { get; set; }

    [JsonProperty("welcomeMessage")]
    public string WelcomeMessage { get; set; }
  }

  var onboardingMessage = new OnboardEventPayload
  {
    Username = "jdoe",
    WelcomeMessage = "Welcome to novu-dotnet"
  };

  var payload = new EventTriggerDataDto()
  {
    EventName = "onboarding",
    To = { SubscriberId = "subscriberId" },
    Payload = onboardingMessage
  };

  var trigger = await novu.Event.Trigger(payload);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "acknowledged": true,
          "status": "processed",
          "transactionId": "string"
      }
  }
  ```
</ResponseExample>

<Accordion title="Idempotent nature of transactionId">
  The `transactionId` within Novu is a unique identifier that is used to ensure the idempotent nature of notification delivery.

  When you trigger an event to send a notification, you have the option to provide a `transactionId`. If you do not provide one, Novu will generate a UUID for you.

  **This identifier is particularly useful for preventing the same notification from being sent multiple times in case the trigger event is inadvertently called more than once.**

  By leveraging the `transactionId`, you can make idempotent requests, which means if the same `transactionId` is used in another request, Novu's API will recognize it and will not send the same notification again.

  <Note>
    This upholds the principle of idempotency, ensuring that the effect of the operation is the same, no matter how many times the request is repeated with the same `transactionId`.
  </Note>
</Accordion>


# API Overview
Source: https://v0.x-docs.novu.co/api-reference/overview

In this page you can learn about how to work with Novu's API

<Note>
  It's important to note that our API and backend SDK are intended for use
  exclusively in server-side applications. **Attempting to use them in a
  client-side application will result in Cross-Origin Resource Sharing (CORS)
  errors.** This restriction ensures the security and integrity of our services.
</Note>

## Authentication

Authentication for the Novu API involves the use of an API Key, which is a secure credential that is tied to your Novu account. This key should be included in the header of the request in the Authorization field as a string prefixed with 'ApiKey '.

```curl theme={null}
--header 'Authorization: ApiKey <NOVU_API_KEY>'
```

For example, when using Novu in a Node.js application, the Novu package should be imported and initialized with the API key, as shown in this snippet:

```javascript theme={null}
import { Novu } from "@novu/node";
const novu = new Novu("<NOVU_API_KEY>");
```

Replace `<NOVU_API_KEY>` with your actual API Key, available in the API Key section of the Novu Dashboard.

<Warning>
  It is advised not to hardcode your credentials in a file in production
  environments. Use environment variables instead.
</Warning>

## API Endpoints

Novu provides a multitude of API endpoints that enable a variety of functionalities.
the base URL for the Novu API is `https://api.novu.co/v1`.

<Note>
  We offer two API options: the US API and the EU API. By default, our API documentation refers to the US API, which can be accessed at: [https://api.novu.co/v1](https://api.novu.co/v1).

  If you require the EU version, you can access it here: [https://eu.api.novu.co/v1](https://eu.api.novu.co/v1).
</Note>

For instance, to get tenant information, the endpoint to use would include the tenant's identifier and look like this `https://api.novu.co/v1/tenants/{identifier}`.


# API Rate Limiting
Source: https://v0.x-docs.novu.co/api-reference/rate-limiting

In this page you can learn about how rate limiting works with Novu's API

<Note>
  This feature is available from v0.22.0.
</Note>

Rate limiting is an essential functionality for establishing a robust and resilient system. It safeguards system resources from being misused by malicious actors or being monopolized by one client.

A variable-cost token bucket rate limited algorithm has been added to provide the capability for different API controllers and methods to have a varying cost. It also lays a foundation for dynamic costing of resource consumption.

## Limits

The following limits apply to each category of the Novu system. Each category has an independent bucket of rate-limit tokens to consume.
Bulk requests have a rate limit cost of 100 times the base limit and consume from the same token pool. For example, the free tier would allow a combined maximum of 10 standard trigger events and 2 bulk trigger events in the same 1-second window.

| Category      | Free   | Business | Endpoints                                                            |
| ------------- | ------ | -------- | -------------------------------------------------------------------- |
| Events        | 60 rps | 600 rps  | Trigger                                                              |
| Configuration | 15 rps | 150 rps  | Subscribers, Topics, Tenants                                         |
| Global        | 30 rps | 300 rps  | All other endpoints consume rate limiting tokens from this category. |


# Bulk create subscribers
Source: https://v0.x-docs.novu.co/api-reference/subscribers/bulk-create-subscribers

post /v1/subscribers/bulk

      Using this endpoint multiple subscribers can be created at once. The bulk API is limited to 500 subscribers per request.
    

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.subscribers.bulkCreate([
      {
          subscriberId: 'test-subscriber-1',
          email: 'test-user@sd.com',
          firstName: 'subscriber-1',
          lastName: 'test-1',
      },
      {
          subscriberId: 'test-subscriber-2',
          email: 'test-user-2@sd.com',
          firstName: 'subscriber-2',
          lastName: 'test-2',
      },
      {
          subscriberId: 'test-subscriber-3',
      },
  ]);
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.subscribers.responses.CreateBulkSubscriberResponse;
  import co.novu.api.subscribers.requests.BulkSubscriberRequest;

  public class Main {
     public static void main(String[] args) {

          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest1 = new SubscriberRequest();
          subscriberRequest1.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest1.setFirstName("<FIRST_NAME>");
          subscriberRequest1.setLastName("<LAST_NAME>");
          subscriberRequest1.setPhone("<PHONE_NUMBER>");
          subscriberRequest1.setAvatar("<AVATAR>");
          subscriberRequest1.setSubscriberId("<SUBSCRIBER_ID>");

          SubscriberRequest subscriberRequest2 = new SubscriberRequest();
          subscriberRequest2.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest2.setFirstName("<FIRST_NAME>");
          subscriberRequest2.setLastName("<LAST_NAME>");
          subscriberRequest2.setPhone("<PHONE_NUMBER>");
          subscriberRequest2.setAvatar("<AVATAR>");
          subscriberRequest2.setSubscriberId("<SUBSCRIBER_ID>");

          BulkSubscriberRequest bulkSubscriberRequest = new BulkSubscriberRequest();
          bulkSubscriberRequest.setSubscribers(Arrays.asList(subscriberRequest1, subscriberRequest2));

          CreateBulkSubscriberResponse response = novu.createSubscriberBulk(bulkSubscriberRequest);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "updated": [],
          "created": [
          {
              "subscriberId": "test-subscriber-1"
          },
          {
              "subscriberId": "test-subscriber-2"
          },
          {
              "subscriberId": "test-subscriber-3"
          }
          ],
          "failed": []
      }
  }
  ```
</ResponseExample>


# Create subscriber
Source: https://v0.x-docs.novu.co/api-reference/subscribers/create-subscriber

post /v1/subscribers
Creates a subscriber entity, in the Novu platform. The subscriber will be later used to receive notifications, and access notification feeds. Communication credentials such as email, phone number, and 3 rd party credentials i.e slack tokens could be later associated to this entity.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --location 'https://api.novu.co/v1/subscribers' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <NOVU_API_KEY>' \
    --data-raw '{
      "firstName": "Pawan",
      "lastName": "Jain",
      "email": "pawan.jain@domain.com",
      "phone": "+1234567890",
      "avatar": "avatar-url",
      "locale": "en-US",
      "data": {
        "isDeveloper": true,
        "customKey": "customValue"
        }
      }'
  ```

  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.subscribers.identify("subscriberId", {
    firstName: "Pawan",
    lastName: "Jain",
    email: "pawan.jain@domain.com",
    phone: "+1234567890",
    avatar: "https://gravatar.com/avatar/553b157d82ac2880237566d5a644e5fe?s=400&d=robohash&r=x",
    locale: "en-US",
    data: {
      isDeveloper: true,
      customKey: "customValue"
    }
  });
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $novu->createSubscriber([
      'subscriberId' => 'YOUR_SYSTEM_USER_ID>',
      'email' => '<insert-email>', // optional
      'firstName' => '<insert-firstname>', // optional
      'lastName' => '<insert-lastname>', // optional
      'phone' => '<insert-phone>', //optional
      'avatar' => '<insert-avatar>', // optional
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'subscriberId' => '7789',
      'email' => '<insert-email>', # optional
      'firstName' => '<insert-firstName>', # optional
      'lastName' => '<insert-lastName>', # optional
      'phone' => '<insert-phone>', # optional
      'avatar' => '<insert-profile-avatar>' # optional
  }
  client.create_subscriber(payload)
  ```

  ```python Python theme={null}
  from novu.dto.subscriber import SubscriberDto
  from novu.api.subscriber import SubscriberApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  # Define a subscriber instance
  subscriber = SubscriberDto(
      email="novu_user@mail.com",
      subscriber_id="82a48af6ac82b3cc2157b57f", #This is what the subscriber_id looks like
      first_name="",  # Optional
      last_name="",  # Optional
      phone="",  # Optional
      avatar="",  # Optional
  )

  # Create a subscriber
  novu = SubscriberApi(url, api_key).create(subscriber)
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.subscribers.responses.CreateSubscriberResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest = new SubscriberRequest();
          subscriberRequest.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest.setFirstName("<FIRST_NAME>");
          subscriberRequest.setLastName("<LAST_NAME>");
          subscriberRequest.setPhone("<PHONE_NUMBER>");
          subscriberRequest.setAvatar("<AVATAR>");
          subscriberRequest.setSubscriberId("<SUBSCRIBER_ID>");

          CreateSubscriberResponse response = novu.createSubscriber(subscriberRequest);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var additionalData = new List<AdditionalDataDto>
  {
    new AdditionalDataDto
    {
      Key = "External ID",
      Value = "1122334455"
    },
    new AdditionalDataDto
    {
      Key = "SMS_PREFERENCE",
      Value = "EMERGENT_ONLY"
    }
  };

  var newSubscriberDto = new CreateSubscriberDto
  {
    SubscriberId = "unique_subscriber_id",
    FirstName = "John",
    LastName = "Doe",
    Avatar = "https://unslpash.com/random",
    Email = "jdoe@novu.co",
    Locale = "en-US",
    Phone = "+11112223333",
    Data = additionalData
  };

  var subscriber = await novu.Subscriber.CreateSubscriber(newSubscriberDto)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "_organizationId": "abcd12349876wxyz1234wxyz",
          "_environmentId": "zyxw4321abcd1234lmno5678",
          "firstName": "Alex",
          "lastName": "Benjamin",
          "phone": "123456789",
          "subscriberId": "abcd1234",
          "email": "alex@email.com",
          "avatar": "string",
          "locale": "en-US",
          "channels": [],
          "_id": "6516ed5a9d727fe8256028ed",
          "deleted": false,
          "createdAt": "2023-09-29T15:29:30.667Z",
          "updatedAt": "2023-09-29T15:29:30.667Z",
          "__v": 0,
          "id": "6516ed5a9d727fe8256028ed"
      }
  }
  ```
</ResponseExample>


# Delete subscriber
Source: https://v0.x-docs.novu.co/api-reference/subscribers/delete-subscriber

delete /v1/subscribers/{subscriberId}
Deletes a subscriber entity from the Novu platform

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.subscribers.delete("subscriberId");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $novu->deleteSubscriber($subscriberId);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.delete_subscriber('<insert-subscriber-id>')
  ```

  ```python Python theme={null}
  from novu.dto.event import InputEventDto
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  # Delete a subscriber
  novu = SubscriberApi(url, api_key).delete(subscriber_id)
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SubscriberDeleteResponse;

  public class Main {
     public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";

          SubscriberDeleteResponse response = novu.deleteSubscriber(subscriberId);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var deleted = await novu.Subscriber.DeleteSubscriber("subscriberId");
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "acknowledged": true,
          "status": "deleted"
      }
  }
  ```
</ResponseExample>


# Delete provider credentials
Source: https://v0.x-docs.novu.co/api-reference/subscribers/delete-subscriber-credentials-by-providerid

delete /v1/subscribers/{subscriberId}/credentials/{providerId}
Delete subscriber credentials for a provider such as **slack** and **FCM** by **providerId**. 
    This action is irreversible and will remove the credentials for the provider for particular **subscriberId**.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Retrieve subscriber notifications
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-in-app-notification-feed-for-a-particular-subscriber

get /v1/subscribers/{subscriberId}/notifications/feed
This API is deprecated, use v2 API instead. Retrieve subscriber in-app notifications by its unique key identifier **subscriberId**.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SubscriberNotificationResponse;

  public class Main {
     public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";

          SubscriberNotificationResponse response = novu.getSubscriberNotificationsFeed(subscriberId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_environmentId": "string",
        "_feedId": "string",
        "_id": "string",
        "_messageTemplateId": "string",
        "_notificationId": "string",
        "_organizationId": "string",
        "_subscriberId": "string",
        "_templateId": "string",
        "channel": "in_app",
        "createdAt": "string",
        "cta": {
          "action": {
            "buttons": [
              {
                "content": "string",
                "resultContent": "string",
                "type": "primary"
              }
            ],
            "result": {
              "payload": "object",
              "type": "primary"
            },
            "status": "pending"
          },
          "data": {
            "url": "string"
          },
          "type": "redirect"
        },
        "deviceTokens": [
          "string"
        ],
        "directWebhookUrl": "string",
        "email": "string",
        "errorId": "string",
        "errorText": "string",
        "lastSeenDate": "string",
        "overrides": "object",
        "payload": "object",
        "phone": "string",
        "providerId": "string",
        "seen": "boolean",
        "status": "sent",
        "subject": "string",
        "subscriber": {
          "__v": "number",
          "_environmentId": "string",
          "_id": "string",
          "_organizationId": "string",
          "avatar": "string",
          "channels": [
            {
              "_integrationId": "string",
              "credentials": {
                "channel": "string",
                "deviceTokens": [
                  "string"
                ],
                "webhookUrl": "string"
              },
              "integrationIdentifier": "string",
              "providerId": "slack"
            }
          ],
          "createdAt": "string",
          "deleted": "boolean",
          "email": "string",
          "firstName": "string",
          "isOnline": "boolean",
          "lastName": "string",
          "lastOnlineAt": "string",
          "locale": "string",
          "phone": "string",
          "subscriberId": "string",
          "updatedAt": "string"
        },
        "template": {
          "_creatorId": "string",
          "_environmentId": "string",
          "_id": "string",
          "_notificationGroupId": "string",
          "_organizationId": "string",
          "_parentId": "string",
          "active": "boolean",
          "critical": "boolean",
          "data": "object",
          "deleted": "boolean",
          "deletedAt": "string",
          "deletedBy": "string",
          "description": "string",
          "draft": "boolean",
          "name": "string",
          "notificationGroup": {
            "_environmentId": "string",
            "_id": "string",
            "_organizationId": "string",
            "_parentId": "string",
            "name": "string"
          },
          "preferenceSettings": {
            "chat": "boolean",
            "email": "boolean",
            "in_app": "boolean",
            "push": "boolean",
            "sms": "boolean"
          },
          "steps": [
            {
              "_id": "string",
              "_parentId": "object",
              "_templateId": "string",
              "active": "boolean",
              "filters": [
                {
                  "children": [
                    {
                      "field": "string",
                      "operator": "LARGER",
                      "true": "subscriber",
                      "value": "string"
                    }
                  ],
                  "isNegated": "boolean",
                  "type": "BOOLEAN",
                  "value": "AND"
                }
              ],
              "name": "string",
              "replyCallback": "object",
              "shouldStopOnFail": "boolean",
              "template": "object",
              "uuid": "string"
            }
          ],
          "tags": [
            "string"
          ],
          "triggers": [
            {
              "identifier": "string",
              "subscriberVariables": [
                {
                  "name": "string"
                }
              ],
              "type": "string",
              "variables": [
                {
                  "name": "string"
                }
              ]
            }
          ],
          "workflowIntegrationStatus": "object"
        },
        "templateIdentifier": "string",
        "title": "string",
        "transactionId": "string"
      }
    ],
    "hasMore": "boolean",
    "page": "number",
    "pageSize": "number"
  }
  ```
</ResponseExample>


# Get subscriber
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-subscriber

get /v1/subscribers/{subscriberId}
Get subscriber by your internal id used to identify the subscriber

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  const response = await novu.subscribers.get("subscriberId");
  console.log(response.data);
  ```

  ```bash cURL theme={null}
  curl --request GET \
    --url https://api.novu.co/v1/subscribers/{subscriberId} \
    --header 'Authorization: <authorization>'
  ```

  ```python Python theme={null}
  import requests

  url = "https://api.novu.co/v1/subscribers/{subscriberId}"

  headers = {"Authorization": "<authorization>"}

  response = requests.request("GET", url, headers=headers)

  print(response.text)
  ```

  ```javascript JavaScript theme={null}
  const options = {method: 'GET', headers: {Authorization: '<authorization>'}};

  fetch('https://api.novu.co/v1/subscribers/{subscriberId}', options)
    .then(response => response.json())
    .then(response => console.log(response))
    .catch(err => console.error(err));
  ```

  ```php PHP theme={null}
  <?php

  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://api.novu.co/v1/subscribers/{subscriberId}",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
      "Authorization: <authorization>"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://api.novu.co/v1/subscribers/{subscriberId}"

  	req, _ := http.NewRequest("GET", url, nil)

  	req.Header.Add("Authorization", "<authorization>")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SingleSubscriberResponse;

  public class Main {
     public static void main(String[] args) {
        String apiKey = "<NOVU_API_KEY>";
        Novu novu = new Novu(apiKey);
        String subscriberId = "<SUBSCRIBER_ID>";

        SingleSubscriberResponse response = novu.getSubscriber(subscriberId);
    }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "firstName": "string",
      "lastName": "string",
      "email": "string",
      "phone": "string",
      "avatar": "string",
      "locale": "string",
      "subscriberId": "string",
      "channels": [
        {
          "providerId": "slack",
          "integrationIdentifier": "string",
          "credentials": {
            "webhookUrl": "string",
            "channel": "string",
            "deviceTokens": [
              "string"
            ]
          },
          "_integrationId": "string"
        }
      ],
      "isOnline": "boolean",
      "lastOnlineAt": "string",
      "_organizationId": "string",
      "_environmentId": "string",
      "deleted": "boolean",
      "createdAt": "string",
      "updatedAt": "string",
      "__v": "number"
    }
  }
  ```
</ResponseExample>


# Get subscriber global preferences
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-subscriber-global-preferences

get /v1/subscribers/{subscriberId}/preferences/{level}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get subscriber preferences
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-subscriber-preferences

get /v1/subscribers/{subscriberId}/preferences

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SubscriberPreferenceResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";

          SubscriberPreferenceResponse response = novu.getSubscriberPreferences(subscriberId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "preference": {
          "channels": {
            "chat": "boolean",
            "email": "boolean",
            "in_app": "boolean",
            "push": "boolean",
            "sms": "boolean"
          },
          "enabled": "boolean"
        },
        "template": {
          "_id": "string",
          "critical": "boolean",
          "name": "string"
        }
      }
    ]
  }
  ```
</ResponseExample>


# Get subscribers
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-subscribers

get /v1/subscribers
Returns a list of subscribers, could paginated using the `page` and `limit` query parameter

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.BulkSubscriberResponse;

  public class Main {
     public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);

          Integer page = 0;
          Integer limit = 10;

          BulkSubscriberResponse response = novu.getSubscribers(page, limit);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "__v": "number",
        "_environmentId": "string",
        "_id": "string",
        "_organizationId": "string",
        "avatar": "string",
        "channels": [
          {
            "_integrationId": "string",
            "credentials": {
              "channel": "string",
              "deviceTokens": [
                "string"
              ],
              "webhookUrl": "string"
            },
            "integrationIdentifier": "string",
            "providerId": "slack"
          }
        ],
        "createdAt": "string",
        "deleted": "boolean",
        "email": "string",
        "firstName": "string",
        "isOnline": "boolean",
        "lastName": "string",
        "lastOnlineAt": "string",
        "locale": "string",
        "phone": "string",
        "subscriberId": "string",
        "updatedAt": "string"
      }
    ],
    "hasMore": "boolean",
    "page": "number",
    "pageSize": "number"
  }
  ```
</ResponseExample>


# Retrieve unseen notifications count
Source: https://v0.x-docs.novu.co/api-reference/subscribers/get-the-unseen-in-app-notifications-count-for-subscribers-feed

get /v1/subscribers/{subscriberId}/notifications/unseen
This API is deprecated, use v2 API instead. Retrieve unseen in-app notifications count for a subscriber by its unique key identifier **subscriberId**.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Handle chat oauth
Source: https://v0.x-docs.novu.co/api-reference/subscribers/handle-chat-oauth

get /v1/subscribers/{subscriberId}/credentials/{providerId}/oauth

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Handle providers oauth redirect
Source: https://v0.x-docs.novu.co/api-reference/subscribers/handle-providers-oauth-redirect

get /v1/subscribers/{subscriberId}/credentials/{providerId}/oauth/callback

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Mark a subscriber feed message as seen
Source: https://v0.x-docs.novu.co/api-reference/subscribers/mark-a-subscriber-feed-message-as-seen

post /v1/subscribers/{subscriberId}/messages/markAs

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update notification action status
Source: https://v0.x-docs.novu.co/api-reference/subscribers/mark-message-action-as-seen

post /v1/subscribers/{subscriberId}/messages/{messageId}/actions/{type}
This API is deprecated, use v2 API instead. Update in-app notification's action status by its unique key identifier **messageId** and type field **type**. 
      **type** field can be **primary** or **secondary**

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update all notifications state
Source: https://v0.x-docs.novu.co/api-reference/subscribers/marks-all-the-subscriber-messages-as-read-unread-seen-or-unseen-optionally-you-can-pass-feed-id-or-array-to-mark-messages-of-a-particular-feed

post /v1/subscribers/{subscriberId}/messages/mark-all
This API is deprecated, use v2 API instead. Update all subscriber in-app notifications state such as read, unread, seen or unseen by **subscriberId**.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update subscriber
Source: https://v0.x-docs.novu.co/api-reference/subscribers/update-subscriber

put /v1/subscribers/{subscriberId}
Used to update the subscriber entity with new information

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SingleSubscriberResponse;
  import co.novu.api.subscribers.requests.UpdateSubscriberRequest;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";

          UpdateSubscriberRequest updateSubscriberRequest = new UpdateSubscriberRequest();
          updateSubscriberRequest.setEmail("<EMAIL_ADDRESS>");
          updateSubscriberRequest.setFirstName("<FIRST_NAME>");
          updateSubscriberRequest.setLastName("<LAST_NAME>");
          updateSubscriberRequest.setPhone("<PHONE_NUMBER>");


          SingleSubscriberResponse response = novu.updateSubscriber(updateSubscriberRequest, subscriberId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "__v": "number",
      "_environmentId": "string",
      "_id": "string",
      "_organizationId": "string",
      "avatar": "string",
      "channels": [
        {
          "_integrationId": "string",
          "credentials": {
            "channel": "string",
            "deviceTokens": [
              "string"
            ],
            "webhookUrl": "string"
          },
          "integrationIdentifier": "string",
          "providerId": "slack"
        }
      ],
      "createdAt": "string",
      "deleted": "boolean",
      "email": "string",
      "firstName": "string",
      "isOnline": "boolean",
      "lastName": "string",
      "lastOnlineAt": "string",
      "locale": "string",
      "phone": "string",
      "subscriberId": "string",
      "updatedAt": "string"
    }
  }
  ```
</ResponseExample>


# Update provider credentials
Source: https://v0.x-docs.novu.co/api-reference/subscribers/update-subscriber-credentials

put /v1/subscribers/{subscriberId}/credentials
Update credentials for a provider such as **slack** and **FCM**. 
      **providerId** is required field. This API creates the **deviceTokens** or replaces the existing ones.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update subscriber global preferences
Source: https://v0.x-docs.novu.co/api-reference/subscribers/update-subscriber-global-preference

patch /v1/subscribers/{subscriberId}/preferences

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update subscriber online status
Source: https://v0.x-docs.novu.co/api-reference/subscribers/update-subscriber-online-status

patch /v1/subscribers/{subscriberId}/online-status
Update the subscriber online status by its unique key identifier **subscriberId**

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.responses.SingleSubscriberResponse;
  import co.novu.api.subscribers.requests.UpdateSubscriberOnlineStatusRequest;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";

          UpdateSubscriberOnlineStatusRequest request = new UpdateSubscriberOnlineStatusRequest();
          request.setIsOnline(true);

          SingleSubscriberResponse response = novu.updateSubscriberOnlineStatus(request, subscriberId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "__v": "number",
      "_environmentId": "string",
      "_id": "string",
      "_organizationId": "string",
      "avatar": "string",
      "channels": [
        {
          "_integrationId": "string",
          "credentials": {
            "channel": "string",
            "deviceTokens": [
              "string"
            ],
            "webhookUrl": "string"
          },
          "integrationIdentifier": "string",
          "providerId": "slack"
        }
      ],
      "createdAt": "string",
      "deleted": "boolean",
      "email": "string",
      "firstName": "string",
      "isOnline": "boolean",
      "lastName": "string",
      "lastOnlineAt": "string",
      "locale": "string",
      "phone": "string",
      "subscriberId": "string",
      "updatedAt": "string"
    }
  }
  ```
</ResponseExample>


# Update subscriber preference
Source: https://v0.x-docs.novu.co/api-reference/subscribers/update-subscriber-preference

patch /v1/subscribers/{subscriberId}/preferences/{templateId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.subscribers.requests.UpdateSubscriberPreferenceRequest;
  import co.novu.api.subscribers.responses.SingleSubscriberPrefResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";
          Novu novu = new Novu(apiKey);
          String subscriberId = "<SUBSCRIBER_ID>";
          String templateId = "<TEMPLATE_ID>";

          PreferenceChannel channel = new PreferenceChannel();
          channel.setType("<TYPE>");
          channel.setEnabled(true);

          UpdateSubscriberPreferenceRequest request = new UpdateSubscriberPreferenceRequest();
          request.setEnabled(false);
          request.setChannel(channel);

          SingleSubscriberPrefResponse response = novu.updateSubscriberPreferences(request, subscriberId, templateId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "preference": {
        "channels": {
          "chat": "boolean",
          "email": "boolean",
          "in_app": "boolean",
          "push": "boolean",
          "sms": "boolean"
        },
        "enabled": "boolean"
      },
      "template": {
        "_id": "string",
        "critical": "boolean",
        "name": "string"
      }
    }
  }
  ```
</ResponseExample>


# Filter topics
Source: https://v0.x-docs.novu.co/api-reference/topics/filter-topics

get /v1/topics
Returns a list of topics that can be paginated using the `page` query parameter and filtered by the topic key with the `key` query parameter

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Topic creation
Source: https://v0.x-docs.novu.co/api-reference/topics/topic-creation

post /v1/topics
Create a topic

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# GitHub Actions
Source: https://v0.x-docs.novu.co/framework/deployment/actions



You can also deploy the workflow state with our built-in GitHub Action command:

```yaml theme={null}
name: Deploy Workflow State to Novu

on:
  push:
    branches:
      - main
jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2
		  - name: Sync State to Novu
		    uses: novuhq/actions-novu-sync@v0.0.4
		    with:
		      novu-api-key: ${{secrets.NOVU_API_KEY}} # Your Dev or Prod API Key to Novu
		      bridge-url: "" # This will be your target environment bridge url
```


# CLI
Source: https://v0.x-docs.novu.co/framework/deployment/cli



The Echo CLI provides a mechanism for you to synchronize your Workflows into Novu Cloud so that non-technical Novu Users can control the Workflow and Step-level inputs and enable your Workflows to be triggered via Novu API.

```bash theme={null}
npx novu-labs@latest sync --echo-url <YOUR URL> --api-key <NOVU_API_KEY>
```


# Going to Production
Source: https://v0.x-docs.novu.co/framework/deployment/production



Novu operates in a multi environment setup. Currently Novu Supports 2 environments:

* **Development** - This is the environment where the development team works on workflows.
* **Production** - This is the environment that is used to trigger workflows to your customers.

## Pushing changes to Cloud

Novu Framework operates in a GitOps model. This means that the source of truth for your workflows and configurations are located in your Git as Code.

The general workflow for pushing changes to Cloud is as follows:

* Create a feature branch
* Develop workflows locally in your Bridge application
* Sync changes to the Development environment to test e2e
* Merge the feature branch to your `dev` branch
  * This will trigger a CI/CD pipeline that will deploy the changes to the Development environment
* Test the changes in the Development environment
* Merge the `dev` branch to the `main` branch
  * This will trigger a CI/CD pipeline that will deploy the changes to the Production environment

## Networking

Novu Cloud workers will need to be able to communicated with your Bridge Endpoint. You will need to ensure that your firewall rules allow traffic from the internet.
Due to the autoscaling nature of Novu Cloud, we don't have a set of IP Addresses that you can whitelist.

## Security

Novu Cloud workers are GDPR, SOC2 type II and ISO 27001 compliant. We take security very seriously and have implemented a number of security measures to ensure that your data is safe.
Novu Framework has a builtin security mechanism that ensures that the requests are authentic from Novu Cloud using an HMAC signature.

HMAC Verification is turned on by default

```typescript theme={null}
export const client = new Client({
  apiKey: process.env.NOVU_API_KEY,,
  strictAuthentication: process.env.NODE_ENV !== "development", // set to true by default
});
```

<Info>
  For local development with Studio `strictAuthentication` should be set to `false`.
</Info>

The `X-Novu-Signature` header included in each signed event contains a timestamp and one or more signatures that we verify.
The timestamp is prefixed by t=, and each signature is prefixed by a scheme.
Schemes start with v, followed by an integer. Currently, the only valid live signature scheme is v1.

Handling the signature verification is done by the Novu Framework, you don't need to perform any action.

## CI/CD Integrations

Novu currently supports the following CI integrations:

* **GitHub Actions** - [Direct Integration](/framework/deployment/actions)
* **GitLab CI** - Using our [CLI command](/framework/deployment/cli)
* **Jenkins** - Using our [CLI command](/framework/deployment/cli)
* **CircleCI** - Using our [CLI command](/framework/deployment/cli)
* **Bitbucket Pipelines** - Using our [CLI command](/framework/deployment/cli)
* **Azure DevOps** - Using our [CLI command](/framework/deployment/cli)
* **Travis CI** - Using our [CLI command](/framework/deployment/cli)
* **Other** - For any other CI/CD tool, you can use our [CLI command](/framework/deployment/cli)

<Info>
  Direct integration with other CI/CD tools is on our roadmap. If you would like to see a specific CI/CD tool integrated, please reach out to us.
</Info>


# React E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/react-email



Integrating Novu Framework with [React.Email](https://react.email/) for your Next.js application can be done in three steps. If you don't have an app, you can create one with the `create-novu-app` command.

<Steps>
  <Step title="Install React.Email components">
    Install the required React.Email components.

    ```bash theme={null}
      npm i @react-email/components react-email
    ```
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.tsx` file for your email template.

    ```tsx theme={null}
    import * as React from "react";
    import { Button, Html } from "@react-email/components";

    function Email(props) {
      return (
        <Html>
          <Button
            href="https://example.com"
            style={{ background: "#000", color: "#fff", padding: "12px 20px" }}
          >
            Click me
          </Button>
        </Html>
      );
    }

    export function renderEmail(inputs) {
      return render(<Email {...inputs} />);
    }
    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```tsx theme={null}
    import { renderEmail } from './sample-email.tsx';
    import { workflow } from '@novu/framework';

    workflow('new-signup', async ({ step, payload }) => {
      await step.email('send-email', async (inputs) => {
        return {
          subject: `Welcome to React E-mail`,
          body: renderEmail(inputs),
        }
      });
    });
    ```
  </Step>
</Steps>


# Remix w/ React E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/remix-react-email



Integrating Novu Framework with [React email](https://react.email/) for your Remix application can be done in three steps. If you don't have an app, you can [clone our Remix example](https://github.com/novuhq/novu-framework-remix-example).

<Steps>
  <Step title="Install React email components">
    Install the required React email components.

    ```bash theme={null}
      npm i @react-email/components react-email
    ```
  </Step>

  <Step title="Create email templates folder">
    Create an `emails` folder in the `app` directory of your Remix app.
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.tsx` file for your email template.

    ```ts theme={null}
    import { Button, Html } from "@react-email/components";

    function Email(props) {
      return (
        <Html>
          <Button
            href="https://example.com"
            style={{ background: "#000", color: "#fff", padding: "12px 20px" }}
          >
            Click me
          </Button>
        </Html>
      );
    }

    export function renderEmail(inputs) {
      return render(<Email {...inputs} />);
    }
    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```tsx theme={null}
    import { renderEmail } from './sample-email.tsx';
    import { workflow } from '@novu/framework';

    workflow('new-signup', async ({ step, payload }) => {
      await step.email('send-email', async (inputs) => {
        return {
          subject: `Welcome to Remix and React E-mail`,
          body: renderEmail(inputs),
        }
      });
    });
    ```
  </Step>
</Steps>


# Svelte E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/svelte-email



Integrating Novu Framework with [Svelte email](https://react.email/) for your Svelte application can be done in three steps. If you don't have an app, you can [clone our Svelte example](https://github.com/novuhq/novu-svelte-email).

<Steps>
  <Step title="Install Svelte email components">
    Install the required Svelte email components.

    ```bash theme={null}
      npm i svelte-email
    ```
  </Step>

  <Step title="Create email templates folder">
    Create an `emails` folder in the `src/lib` directory of your Svelte app.
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.svelte` file for your email template.

    ```ts theme={null}
    <script lang="ts">
        import { Button, Container, Head, Hr, Html, Img, Preview, Section, Text } from 'svelte-email';

        export let firstName = 'John';

        const fontFamily =
            '-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen-Sans,Ubuntu,Cantarell,"Helvetica Neue",sans-serif';

        const main = {
            backgroundColor: '#ffffff'
        };

        const container = {
            margin: '0 auto',
            padding: '20px 0 48px'
        };

        const logo = {
            margin: '0 auto'
        };

        const paragraph = {
            fontFamily,
            fontSize: '16px',
            lineHeight: '26px'
        };

        const btnContainer = {
            textAlign: 'center' as const
        };

        const button = {
            fontFamily,
            backgroundColor: '#5F51E8',
            borderRadius: '3px',
            color: '#fff',
            fontSize: '16px',
            textDecoration: 'none',
            textAlign: 'center' as const,
            display: 'block'
        };

        const hr = {
            borderColor: '#cccccc',
            margin: '20px 0'
        };

        const footer = {
            fontFamily,
            color: '#8898aa',
            fontSize: '12px'
        };
    </script>

    <Html lang="en">
        <Head />
        <Preview preview="Welcome to svelte-email" />
        <Section style={main}>
            <Container style={container}>
                <Img
                    src="https://svelte.dev/svelte-logo-horizontal.svg"
                    alt="Svelte logo"
                    style={logo}
                    width="200"
                    height="50"
                />
                <Text style={paragraph}>{firstName}, welcome to svelte-email</Text>
                <Text style={paragraph}>A Svelte component library for building responsive emails</Text>
                <Section style={btnContainer}>
                    <Button pX={12} pY={12} style={button} href="https://github.com/carstenlebek/svelte-email">
                        View on GitHub
                    </Button>
                </Section>
                <Text style={paragraph}>Happy coding!</Text>
                <Hr style={hr} />
                <Text style={footer}>Carsten Lebek</Text>
            </Container>
        </Section>
    </Html>
    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```tsx theme={null}
    import WelcomeEmail from '$lib/emails/sample-email.svelte';
    import { render } from 'svelte-email';
    import { workflow } from '@novu/framework';

    workflow('new-signup', async ({ step, payload }) => {
        await step.email(
            'send-email',
            async (inputs) => {
                const html = render({
                    template: WelcomeEmail,
                    props: {
                        firstName: 'John',
                    },
                });
                return {
                    subject: `Welcome to Svelte E-mail`,
                    body: html,
                }
            });
        }
    );
    ```
  </Step>
</Steps>


# Vue E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/vue-email



You can integrate Novu Framework with [Vue Email](https://vuemail.net/) in a few simple steps. This guide will walk you through the process of creating a new email template using Vue Email and Nuxt.

For a Quickstart Boilerplate project using Nuxt.js, and Vue Email, check out the [Vue Email Starter repository](https://github.com/novuhq/novu-framework-nuxt-example/)

## Quickstart

<Steps>
  <Step title="Install Vue.Email components">
    Install the required Vue.Email components.

    ```bash theme={null}
    npm install vue-email @vue-email/compiler @vue-email/nuxt
    ```
  </Step>

  <Step title="Create templates folder">
    Create a `templates` folder in the root of your Nuxt app
  </Step>

  <Step title="Update nuxt.config.ts File">
    Update your `nuxt.config.ts` file to include the Vue Email module.

    ```ts nuxt.config.ts theme={null}
    export default defineNuxtConfig({
        devtools: { enabled: true },
        components: true,

        modules: [
            '@vue-email/nuxt',
        ],
    })
    ```
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.vue` file in the `templates` folder for your email template.

    ```vue theme={null}
    <script setup lang="ts">
        import { defineProps, withDefaults } from 'vue'

        interface Props {

        }

        const baseUrl = "https://react-email-demo-bdj5iju9r-resend.vercel.app";

        const props = withDefaults(defineProps<Props>(), {});
    </script>

    <template>
        <ETailwind>
            <EHtml>
                <EHead/>
                <EPreview>Email Preview Text</EPreview>
                <EBody class="bg-white my-auto mx-auto font-sans">
                    <EContainer class="border border-solid border-[#eaeaea] p-[20px] md:p-7 rounded my-[40px] mx-auto max-w-[465px]">
                        <EHeading class="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
                            Hello World!
                        </EHeading>
                    </EContainer>
                </EBody>
            </EHtml>
        </ETailwind>
    </template>

    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```ts theme={null}
    import { config } from '@vue-email/compiler';
    import { workflow } from '@novu/framework';

    const vueEmail = config('templates', {
        verbose: false,
        options: {},
    });


    workflow('new-signup', async ({step, payload}) => {
        await step.email('send-email', async (inputs) => {
            const template = await vueEmail.render('sample-email.vue', {
                props: inputs
            })

            return {
                subject: `Welcome to Vue E-mail`,
                body: template.html
            }
        });
    });
    ```
  </Step>
</Steps>

## Learn More

To learn more, refer to [Vue Email documentation](https://vuemail.net/).


# No-Code Tools to control your Notification Flows
Source: https://v0.x-docs.novu.co/framework/non-developers/introduction

Change notification content and behavior with confidence using Novu Web UI.

Novu Framework was designed to bridge the gap between developers and on-developers in the team.

* **Developers** - Define and abstract away complex logic, data manipulation and hydration, html and etc...
* **Non-Developers** - Use the Novu Web UI to control the content and behavior of the notifications using [Inputs](/framework/concepts/inputs).

## How to Modify Inputs?

Inputs are modified directly on the [Novu Web UI](https://web.novu.co). Each Workflow editor page have an 'Inputs' tab where you can modify them.
When Saving the changes, the new Input values will be used in the notification sent to your subscriber.

## Common Input Usecases

### Change Notification Content

An input can be as broad as `content` or as specific as `2fa_code_title_color`. This allows you to change the content of the notification without needing to touch the code.

<Tip>
  Currently you cannot use Dynamic payload variables as part of the Input. Reach out to us if you need this capability.
</Tip>

### Change Digest or Delay Frequency

Inputs can be used for controlling any aspect of the step configuration, for example:

* Digest Length
* Delay Amount
* Digest Type (Daily, Weekly, Monthly)
* etc...

### Control structure and layout

Inputs can be used to show/hide or rearrange the layout of the notification.
For example, you can have an input to show/hide a button, or change the position of a specific email section.


# JSON Schema
Source: https://v0.x-docs.novu.co/framework/recipes/json-schema



JSON Schema can be used to define the [Workflow Payload](/framework/concepts/inputs) and [Step Inputs](/framework/concepts/inputs).
It provides a strongly-typed way to define the structure of the data that is expected by the Workflow or Step.
And also as a contract for changing the Workflow behaviour using the Platform User Interface.

Learn more about JSON Schema at [json-schema.org](https://json-schema.org/).

## Examples

### Simple

```json theme={null}
{
  "type": "object",
  "required": [
    "firstName",
    "lastName"
  ],
  "properties": {
    "firstName": {
      "type": "string",
      "title": "First name",
      "default": "Chuck"
    },
    "lastName": {
      "type": "string",
      "title": "Last name"
    },
    "age": {
      "type": "integer",
      "title": "Age"
    }
  }
}
```

### Nested Array Structure

```json theme={null}
{
  "type": "object",
  "required": [
    "title"
  ],
  "properties": {
    "title": {
      "type": "string",
      "title": "Task list title"
    },
    "tasks": {
      "type": "array",
      "title": "Tasks",
      "items": {
        "type": "object",
        "required": [
          "title"
        ],
        "properties": {
          "title": {
            "type": "string",
            "title": "Title",
            "description": "A sample title"
          },
          "details": {
            "type": "string",
            "title": "Task details",
            "description": "Enter the task details"
          },
          "done": {
            "type": "boolean",
            "title": "Done?",
            "default": false
          }
        }
      }
    }
  }
}
```

### Reference and Reuse Blocks

```json theme={null}
{
  "definitions": {
    "address": {
      "type": "object",
      "properties": {
        "street_address": {
          "type": "string"
        },
        "city": {
          "type": "string"
        },
        "state": {
          "type": "string"
        }
      },
      "required": [
        "street_address",
        "city",
        "state"
      ]
    },
    "node": {
      "type": "object",
      "properties": {
        "name": {
          "type": "string"
        },
        "children": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/node"
          }
        }
      }
    }
  },
  "type": "object",
  "properties": {
    "billing_address": {
      "title": "Billing address",
      "$ref": "#/definitions/address"
    },
    "shipping_address": {
      "title": "Shipping address",
      "$ref": "#/definitions/address"
    },
    "tree": {
      "title": "Recursive references",
      "$ref": "#/definitions/node"
    }
  }
}
```

### Any Of Schemas

```json theme={null}
{
  "type": "object",
  "properties": {
    "age": {
      "type": "integer",
      "title": "Age"
    },
    "items": {
      "type": "array",
      "items": {
        "type": "object",
        "anyOf": [
          {
            "properties": {
              "foo": {
                "type": "string"
              }
            }
          },
          {
            "properties": {
              "bar": {
                "type": "string"
              }
            }
          }
        ]
      }
    }
  },
  "anyOf": [
    {
      "title": "First method of identification",
      "properties": {
        "firstName": {
          "type": "string",
          "title": "First name",
          "default": "Chuck"
        },
        "lastName": {
          "type": "string",
          "title": "Last name"
        }
      }
    },
    {
      "title": "Second method of identification",
      "properties": {
        "idCode": {
          "type": "string",
          "title": "ID code"
        }
      }
    }
  ]
}
```

### One Of Schema

```json theme={null}
{
  "type": "object",
  "oneOf": [
    {
      "properties": {
        "lorem": {
          "type": "string"
        }
      },
      "required": [
        "lorem"
      ]
    },
    {
      "properties": {
        "ipsum": {
          "type": "string"
        }
      },
      "required": [
        "ipsum"
      ]
    }
  ]
}
```

### If Then Else

```json theme={null}
{
  "type": "object",
  "properties": {
    "animal": {
      "enum": [
        "Cat",
        "Fish"
      ]
    }
  },
  "allOf": [
    {
      "if": {
        "properties": {
          "animal": {
            "const": "Cat"
          }
        }
      },
      "then": {
        "properties": {
          "food": {
            "type": "string",
            "enum": [
              "meat",
              "grass",
              "fish"
            ]
          }
        },
        "required": [
          "food"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "animal": {
            "const": "Fish"
          }
        }
      },
      "then": {
        "properties": {
          "food": {
            "type": "string",
            "enum": [
              "insect",
              "worms"
            ]
          },
          "water": {
            "type": "string",
            "enum": [
              "lake",
              "sea"
            ]
          }
        },
        "required": [
          "food",
          "water"
        ]
      }
    },
    {
      "required": [
        "animal"
      ]
    }
  ]
}
```

### Enum Objects

```json theme={null}
{
  "definitions": {
    "locations": {
      "enumNames": [
        "New York",
        "Amsterdam",
        "Hong Kong"
      ],
      "enum": [
        {
          "name": "New York",
          "lat": 40,
          "lon": 74
        },
        {
          "name": "Amsterdam",
          "lat": 52,
          "lon": 5
        },
        {
          "name": "Hong Kong",
          "lat": 22,
          "lon": 114
        }
      ]
    }
  },
  "type": "object",
  "properties": {
    "location": {
      "title": "Location",
      "$ref": "#/definitions/locations"
    },
    "locationRadio": {
      "title": "Location Radio",
      "$ref": "#/definitions/locations"
    },
    "multiSelect": {
      "title": "Locations",
      "type": "array",
      "uniqueItems": true,
      "items": {
        "$ref": "#/definitions/locations"
      }
    },
    "checkboxes": {
      "title": "Locations Checkboxes",
      "type": "array",
      "uniqueItems": true,
      "items": {
        "$ref": "#/definitions/locations"
      }
    }
  }
}
```

### Regex Validation

The following example matches a simple North American telephone number with an optional area code:

```json theme={null}
{
  "type": "object",
  "properties": {
    "phone": {
      "type": "string",
      "pattern": "^(\\([0-9]{3}\\))?[0-9]{3}-[0-9]{4}$"
    }
  }
}
```

## Other Resources

* [Examples](https://json-schema.org/learn/miscellaneous-examples)
* [React JSON Schema](https://rjsf-team.github.io/react-jsonschema-form/)
* [JSON Schema Validator](https://www.jsonschemavalidator.net/)
* [JSON Schema Lint](https://jsonschemalint.com/)


# Integrate Novu with Express.js
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/express



```tsx theme={null}
import { serve } from "@novu/framework/express";
import { myWorkflow } from "../novu/workflows";

app.use(express.json()); // Required for Novu POST requests
app.use(
  "/api/novu",
  serve({ workflows: [myWorkflow] })
);
```


# Integrate Novu with H3
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/h3



```tsx theme={null}
import { createApp, eventHandler, toNodeListener } from "h3";
import { serve } from "@novu/framework/h3";
import { createServer } from "node:http";
import { myWorkflow } from "./novu/workflows";

const app = createApp();
app.use(
  "/api/novu",
  eventHandler(
    serve({
      workflows: [myWorkflow],
    })
  )
);

createServer(toNodeListener(app)).listen(process.env.PORT || 3000);
```


# Integrate Novu with Nuxt
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/nuxt



Novu Framework works out of the box with Nuxt.js. You can use the `@novu/framework/nuxt` package to serve your Bridge endpoint in your Nuxt.js application.

For a boilerplate project with Vue Email, view: [Nuxt.js Boilerplate](https://github.com/novuhq/novu-framework-nuxt-example/)

<CodeGroup>
  ```ts API Routes theme={null}
  import { serve } from "@novu/framework/nuxt";
  import { myWorkflow } from "../workflows";

  export default defineEventHandler(serve({ workflows: [myWorkflow] }));
  ```
</CodeGroup>

Check out a comprehensive [guide on sending notifications in Nuxt with Vuemail](/guides/framework-guides/framework-nuxt-vuemail).


# Integrate Novu with Remix
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/remix



```tsx theme={null}
import { serve } from "@novu/framework/remix";
import { myWorkflow } from "../novu/workflows";

const handler = serve({
    workflows: [myWorkflow],
  });
  
export { handler as action, handler as loader };
```

Check out a comprehensive [guide on sending notifications in Remix with React email](/guides/framework-guides/framework-remix).


# Integrate Novu with SvelteKit
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/sveltekit



```tsx theme={null}
import { myWorkflow } from '../workflows';
import { serve } from '@novu/framework/sveltekit';

export const { GET, POST, PUT } = serve({ workflows: [myWorkflow] });
```

Check out a comprehensive [guide on sending notifications in Svelte with Svelte-email](/guides/framework-guides/framework-svelte).


# Typescript
Source: https://v0.x-docs.novu.co/framework/sdk/typescript



Novu Framework was built and optimized for extreme focus on Developer Experience.
Our `@novu/framework` SDK is written in Typescript, and we recommend using Typescript for your own projects as well.

<EchoTerminal />

## Type Safe Workflow Payloads

When defining a [workflow payload](/framework/concepts/payload) schema, our SDK will automatically infer it to a Typescript interface.

```typescript theme={null}
import { workflow } from '@novu/framework';

const myWorkflow = workflow('new-signup', async ({ step, payload }) => {
	await step.email('send-email', () => {
        return {
            subject: 'Hello World',
            // The payload object here is type-safe
            body: `Hi ${payload.name}, welcome to our platform!`
        }
	});
}, {
	// JSON Schema for validation and type-safety. Zod, and others coming soon.
	// https://json-schema.org/draft-07/json-schema-release-notes
	payloadSchema: { properties: { name: { type: 'string' }}},
});
```

## Type Safe Steps

Similarly, when defining a [step](/framework/concepts/steps) schema, our SDK will automatically infer it to a Typescript interface.


# How to send PUSH notifications to iOS devices with FCM using Novu
Source: https://v0.x-docs.novu.co/guides/FCM-iOS-Novu/how-to-send-PUSH-notifications-to-iOS-devices-with-FCM-using-Novu

Learn how to integrate Firebase Cloud Messaging with Novu and send notifications to iOS

## Prerequisites

To complete this tutorial, you will need the following:

* [Apple Developer](https://developer.apple.com/) membership (to obtain the required permissions to send push notifications)
* A machine running MacOS to work on an iOS project
* [Firebase](https://firebase.google.com/) account
* [Novu](https://web.novu.co/?utm_campaign=docs-gs-guides-fcm-ios) account
* [Xcode](https://developer.apple.com/xcode/) installed on your machine

## Create an iOS app

Open Xcode and create a new project, choosing the **App** template.

Give your project a name, and select your name as the team for now, or leave it blank.

Your bundle identifier will be generated here — you will use this later when connecting to Firebase.

Select **SwiftUI** as your interface and **Swift** as your language.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Let's build and run our iOS application to see if everything works correctly.

<Frame>
  <img />
</Frame>

Go to the Firebase documentation website, go to docs here, and select Cloud Messaging.
We will follow this guide to set up cloud messaging inside the app.

You can read more about how Firebase Cloud Messaging works by reading their [official documentation](https://firebase.google.com/docs/cloud-messaging/ios/client).

<Frame>
  <img />
</Frame>

Go to iOS+ and click on the `Set up an Apple platforms client` section.

<Frame>
  <img />
</Frame>

The first thing that we need to do is add Firebase to our iOS app.
Let's create a new Firebase project inside of the console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Create a Firebase project

Select a name for your project.

<Frame>
  <img />
</Frame>

Then, add Google Analytics to the Firebase project.

<Frame>
  <img />
</Frame>

Here, you can select your Google account.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We will click on Add Firebase to your iOS app.

<Frame>
  <img />
</Frame>

We first need to add the bundle name, so go to your iOS Xcode project and copy and paste the bundle name.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Download the `.plist` file and put it in the root of your project.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

You can put it right under `info.plist` file.

<Frame>
  <img />
</Frame>

We need to add the Firebase SDK using the Swift package manager.
Copy this [https://github.com/firebase/firebase-ios-sdk](https://github.com/firebase/firebase-ios-sdk) URL and then go to 'File`->`Add Package Dependencies...\`.
Paste that URL in the top right.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We must add the initialization code to the `AppDelegates.swift` file.

Let's import the "FirebaseCore" dependency by adding `import FirebaseCore` to the beginning of the file.

Then, we will copy `firebaseapp.configure()` and place it in `didFinishLaunchingWithOptions` method.

<Frame>
  <img />
</Frame>

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore //Here

@main
class AppDelegate: UIResponder, UIApplicationDelegate {



    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure() //Here
				FirebaseConfiguration.shared.setLoggerLevel(.min)
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

```

Click 'Next' and continue to the console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Let's build and run our project and see if we get Firebase log messages in the console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Create and upload our APNs authentication key

We will create and upload our APNs authentication key to the Firebase project settings.

<Frame>
  <img />
</Frame>

Navigate to [Apple Developer Member Center](https://developer.apple.com/account).

Head to the "Keys" section under "Certificates, IDs & Profiles".

<Frame>
  <img />
</Frame>

Create a new key.

<Frame>
  <img />
</Frame>

Select "Apple Push Notification Service".

<Frame>
  <img />
</Frame>

Click "Register".

<Frame>
  <img />
</Frame>

We have to download this key and upload it into Firebase.

<Frame>
  <img />
</Frame>

Head to "Project Settings".

<Frame>
  <img />
</Frame>

Click on Cloud Messaging, then click "Upload APNs Authentication Key".

<Frame>
  <img />
</Frame>

Now we can upload the dots p8 file.

<Frame>
  <img />
</Frame>

You must enter your `Key ID` and `Team ID`, which you can find in the top right corner.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Register for Remote Notifications

<Frame>
  <img />
</Frame>

1. Copy this code block and place it inside the `AppDelegate.swift` file using the `didFinishLaunchingWithOptions` method.
   We paste this code block under `firebaseApp.configure()`.

2. We need to conform to this delegate, so we will also create an `AppDelegate` extension at the bottom for `UNUserNotificationCenterDelegate`.

3. Add `import FirebaseMessaging` to the file.

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {



    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
}

```

## Access the Registration Token

To do this, we must first set the `Messaging.messaging().delegate = self` inside the `didFinishLaunchingWithOptions` method.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We will now add a 'Messaging' delegate extension to `AppDelegate.swift` file.

<Frame>
  <img />
</Frame>

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce on 13/01/2024.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {



    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        FirebaseConfiguration.shared.setLoggerLevel(.min)

        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()
        
        // Messaging Delegate
        
        Messaging.messaging().delegate = self

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
      // Receive displayed notifications for iOS 10 devices.
      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  willPresent notification: UNNotification) async
        -> UNNotificationPresentationOptions {
        let userInfo = notification.request.content.userInfo

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // ...

        // Print full message.
        print(userInfo)

        // Change this to your preferred presentation option
        return [[.alert, .sound]]
      }

      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  didReceive response: UNNotificationResponse) async {
        let userInfo = response.notification.request.content.userInfo

        // ...

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // Print full message.
        print(userInfo)
      }
    }
    


extension AppDelegate: MessagingDelegate {
  
  func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
    print("Firebase registration token: \(String(describing: fcmToken))")
    
    let dataDict: [String: String] = ["token": fcmToken ?? ""]
    NotificationCenter.default.post(
      name: Notification.Name("FCMToken"),
      object: nil,
      userInfo: dataDict
    )
    // TODO: If necessary send token to application server.
    // Note: This callback is fired at each app startup and whenever a new token is generated.
  }
  
  
}

```

## Receive messages in an Apple App

1. Copy this code block and place it in `UNUserNotificationCenterDelegate` extension.
2. Add the `didReceiveRemoteNotification`.
3. We must declare a `gcmMessageIDKey` inside of `AppDelegate`. We can define this as a `string` variable.

<Frame>
  <img />
</Frame>

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    let gcmMessageIDKey = "gcm.Message_ID"

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        FirebaseConfiguration.shared.setLoggerLevel(.min)

        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()
        
        // Messaging Delegate
        
        Messaging.messaging().delegate = self

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
      // Receive displayed notifications for iOS 10 devices.
      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  willPresent notification: UNNotification) async
        -> UNNotificationPresentationOptions {
        let userInfo = notification.request.content.userInfo

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // ...

        // Print full message.
        print(userInfo)

        // Change this to your preferred presentation option
        return [[.alert, .sound]]
      }

      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  didReceive response: UNNotificationResponse) async {
        let userInfo = response.notification.request.content.userInfo

        // ...

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // Print full message.
        print(userInfo)
      }
    
    func application(_ application: UIApplication,
                     didReceiveRemoteNotification userInfo: [AnyHashable: Any]) async
      -> UIBackgroundFetchResult {
      // If you are receiving a notification message while your app is in the background,
      // this callback will not be fired till the user taps on the notification launching the application.
      // TODO: Handle data of notification

      // With swizzling disabled you must let Messaging know about the message, for Analytics
      // Messaging.messaging().appDidReceiveMessage(userInfo)

      // Print message ID.
      if let messageID = userInfo[gcmMessageIDKey] {
        print("Message ID: \(messageID)")
      }

      // Print full message.
      print(userInfo)

      return UIBackgroundFetchResult.newData
    }

    
    }
    


extension AppDelegate: MessagingDelegate {
  
  func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
    print("Firebase registration token: \(String(describing: fcmToken))")
    
    let dataDict: [String: String] = ["token": fcmToken ?? ""]
    NotificationCenter.default.post(
      name: Notification.Name("FCMToken"),
      object: nil,
      userInfo: dataDict
    )
    // TODO: If necessary send token to application server.
    // Note: This callback is fired at each app startup and whenever a new token is generated.
  }
  
  
}

```

## Adding app capabilities

<Frame>
  <img />
</Frame>

Click on the plus sign (+) and select `Background Modes`.

<Frame>
  <img />
</Frame>

**Select the following options:**

* Background Fetch
* Remote Notifications
* Background Processing

<Frame>
  <img />
</Frame>

Add `Push Notifications` capabilities.

<Frame>
  <img />
</Frame>

## App Build

<Frame>
  <img />
</Frame>

It will ask if you want to receive notifications, and we will allow it.

<Frame>
  <img />
</Frame>

## Cloud Message Test

In your Firebase project, navigate to 'engage' section and click on 'messaging'.

<Frame>
  <img />
</Frame>

Click on "Send your first message".

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We're going to enter the `notification title` and the `notification text`, then we're going to send the test message.

<Frame>
  <img />
</Frame>

We must copy and paste this FCM registration token to confirm our device (A physical or a simulator). You can find it in your Xcode console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Click on 'Test'.

<Frame>
  <img />
</Frame>

You should see the notification on your device!

<Frame>
  <img />
</Frame>

## Novu account creation

<Frame>
  <img />
</Frame>

You can immediately configure FCM as a Push channel provider or navigate to the Integration Store.

<Frame>
  <img />
</Frame>

## Connecting FCM as a provider

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

You only need to configure FCM with Novu with the Firebase Service Accounts private key.

To acquire the account key JSON file for your service account, follow this instructions:

1. Select your project. Click the gear icon on the top of the sidebar.
2. Head to project settings.
3. Navigate to the service account tab.
4. Click "Generate New Private Key", then confirm by clicking "Generate Key".
5. Clicking Generate Key will download the JSON file.
6. Once the file is on your machine, paste the entire JSON file content in the Service Account field of the FCM provider in the integration store on Novu’s web dashboard.

Make sure your service account key JSON content contains these fields:

```JSON theme={null}

{
  "type": "service_account",
  "project_id": "PROJECT_ID",
  "private_key_id": "PRIVATE_KEY_ID",
  "private_key": "PRIVATE_KEY",
  "client_email": "FIREBASE_ADMIN_SDK_EMAIL",
  "client_id": "CLIENT_ID",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "CLIENT_X509_CERT_URL"
}

```

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Creating a workflow

In Novu, creating a workflow means establishing a blueprint for sending notifications within your app. This unified structure ties together email, in-app messages, SMS, push notifications, and chat into **one entity**.

Each workflow has a unique name and identifier and includes customized content for various channels, using `{{handlebars}}` variables for personalization.

This ensures consistent platform notifications and allows dynamic adjustments for individual subscribers, scenarios, and use cases.

Workflow creation is for streamlining automated notifications, enabling teams to communicate effectively without extensive technical expertise.

<Steps>
  <Step title="Nabigate to 'Workflows' tab and click on 'Blank Workflow'">
    <Frame>
      <img />
    </Frame>

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Add (Drag & Drop) the Push channel node to the workflow">
    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Click on the node, and start to modify the content. Once you are done, click on 'Update'">
    <Frame>
      <img />
    </Frame>
  </Step>
</Steps>

## Creating a subscriber

Creating a subscriber in Novu refers to the process of establishing a subscriber entity within the Novu platform. A subscriber is essentially the recipient of the notifications sent through Novu's system. When you create a subscriber, you're setting up the necessary information for Novu to send targeted notifications to that individual.

<Frame>
  <img />
</Frame>

<Steps>
  <Step title="Creating a subscriber">
    ```JSON theme={null}

    curl --location 'https://api.novu.co/v1/subscribers' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <YOUR_API_KEY>' \
    --data-raw '{
    "subscriberId": "12345678",
    "firstName": "Pawan",
    "lastName": "Jain",
    "email": "pawan.jain@domain.com",
    "phone": "+1234567890",
    "avatar": "avatar-url",
    "locale": "en-US",
    "data": {
      "isDeveloper": true,
      "customKey": "customValue"
      }
    }'

    ```

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Locating subscriber's FCM registration token">
    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Adding the registration token to the subscriber">
    <Note> Subscriber can have multiple device tokens </Note>

    Here, you can locate the Provider\_Identifier.

    <Frame>
      <img />
    </Frame>

    ```JSON theme={null}

        curl --request PUT \
      --url https://api.novu.co/v1/subscribers/{subscriber_id}/credentials \
    --header 'Content-Type: application/json' \
      --header 'Authorization: ApiKey <YOUR_API_KEY>' \
      --data '{
      "credentials":{
        "deviceTokens": ["token1", "token2"]
    },
      "integrationIdentifier":"<Provider_Identifier>",
      "providerId":"fcm"
    }'

    ```
  </Step>
</Steps>

## Sending a notification to iOS device with Novu

To send a notification with Novu, you are actually triggering a notification workflow.
You have the ability to test the trigger using the user interface or by calling Novu's API.

**Trigger a workflow via the API**

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "<REPLACE_WITH_DATA>"
         },
         "payload": {}
       }'

```

<Frame>
  <img />
</Frame>

## Dynamic Content

When we were creating the first workflow, we "Hardcoded" the content of the notification.

Now, we will determine the content when calling the API.

1. In the workflow, we should change the values of the `title` and the `body` to `{{title}}` and `{{body}}`.
   That way, we could insert values through the payload of the API call.

<Frame>
  <img />
</Frame>

2. Add a 'payload' object to the API call.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "This title was set via the Payload",
           "body": "Payload notification body"
         },
       }'

```

<Frame>
  <img />
</Frame>

## Sound of a notification

The name of a sound file in your app's main bundle or in the Library/Sounds folder of your app's container directory.
Specify the string "default" to play the system sound.

Use this key for regular notifications. For critical alerts, use the sound dictionary instead.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "Notification With Sound",
           "body": "Hello World from Novu"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "payload": {
                 "aps": {
                   "sound": "default" // configure sound to the notification
                 }
               }
             }
           }
         }
       }'

```

## Priority for notification

If you omit this header, APNs set the notification priority to `10`.

Specify `10` to send the notification immediately.

Specify `5` to send the notification based on power considerations on the user’s device.

Specify `1` to prioritize the device’s power considerations over all other factors for delivery and prevent awakening the device.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "apns-priority: 5",
           "body": "Novu's API"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "headers": {
				 "apns-priority":"5" //priority for notifications
			   },
               "payload": {
                 "aps": {}
               },
               "fcm_options": {}
             }
           }
         }
       }'

```

## Sending images

Up to this point, your notifications have all contained only text. But if you’ve received many notifications, you know that notifications can have rich content, such as images. It’d be great if your notifications showed users a nice image related to their content. Once again, Firebase makes this super simple.

To show an image in push notifications, you’ll need to create a ***Notification Service Extension***. This is a separate target in your app that runs in the background when your user receives a push notification. The service extension can receive a notification and change its contents before iOS shows the notification to the user.
You’ll use Firebase to send an image URL inside a notification.
You’ll then use a content extension to download the image and add it to the notification’s content.

In Xcode, go to File ▸ New ▸ Target…. Search for Notification Service Extension and select Next. Set a name and configure it to add to your main project.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Select **Finish**, and when prompted, select **Activate**.

<Frame>
  <img />
</Frame>

When you added the Firebase package to your project, it was only added to the your "main" (In my case it's "PushNotificationDemo") target, so now you need to add the necessary dependency to your new extension.
Open your app’s project settings and select the name you picked for the extention under Targets.

Under Frameworks and Libraries, select the + button, and search for FirebaseMessaging. Then, select Add. Your project should reflect the image below:

<Frame>
  <img />
</Frame>

Select the + button, and search for FirebaseMessaging. Then, select Add.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Now, open `NotificationService.swift`. This file is where you can customize notifications before the user sees them.

First, add the following import to the top of the file:
`import FirebaseMessaging`

Next, replace the contents of `didReceive(_:withContentHandler:)` with the following:

```Swift theme={null}

self.contentHandler = contentHandler
bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)
        
if let bestAttemptContent = bestAttemptContent {
// Modify the notification content here...
bestAttemptContent.title = "\(bestAttemptContent.title)"
            
// Call FIRMessaging extension helper API.

if let messagingContentHandler = self.contentHandler {
Messaging.serviceExtension().populateNotificationContent(bestAttemptContent, withContentHandler: messagingContentHandler)
 }
}

```

Typically, you’d have to search the field containing the image URL, download the image, and finish the presentation with the picture as an attachment.
Here, you’re using Firebase’s `FIRMessagingExtensionHelper` to perform all that work automatically in a straightforward helper method call.

Remember, iOS only allows you to download your attached image. If the extension’s code takes too long to run, the system will call `serviceExtensionTimeWillExpire()`.
This gives you a chance to gracefully finish up anything you are doing in the extension or to simply present the notification as is, which is the default implementation.

This is the entire `NotificationService.swift` file.

```Swift theme={null}

//
//  NotificationService.swift
//  Rich Notifications
//
//  Created by Emillien Pearce.
//

import UserNotifications
import FirebaseMessaging

class NotificationService: UNNotificationServiceExtension {

    var contentHandler: ((UNNotificationContent) -> Void)?
    var bestAttemptContent: UNMutableNotificationContent?

    override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
        
        self.contentHandler = contentHandler
        bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)
        
        if let bestAttemptContent = bestAttemptContent {
            // Modify the notification content here...
            bestAttemptContent.title = "\(bestAttemptContent.title)"
            
            // Call FIRMessaging extension helper API.
            if let messagingContentHandler = self.contentHandler {
                Messaging.serviceExtension().populateNotificationContent(bestAttemptContent, withContentHandler: messagingContentHandler)
            }
        }
    }
    
    override func serviceExtensionTimeWillExpire() {
        // Called just before the extension will be terminated by the system.
        // Use this as an opportunity to deliver your "best attempt" at modified content, otherwise the original push payload will be used.
        if let contentHandler = contentHandler, let bestAttemptContent =  bestAttemptContent {
            contentHandler(bestAttemptContent)
        }
    }

}

```

Let's **rebuild** our app again!

<Frame>
  <img />
</Frame>

When making the API call, we should include:

* "mutable-content": 1 inside the "aps" object.
* "image" in "fcm\_options" object,
* URL address of the image.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "This is a notification with an image",
           "body": "Check this out"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "headers": {},
               "payload": {
        "aps": {
          "mutable-content": 1
                 }
               },
      "fcm_options": {
        "image": "https://www.planetware.com/wpimages/2020/02/france-in-pictures-beautiful-places-to-photograph-eiffel-tower.jpg"
               }
             }
           }
         }
       }'

```

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Sending actionable notifications

1. Define Notification Actions:

In your `AppDelegate.swift` file, you should define the notification actions you want to add.
You can do this by creating a `UNNotificationAction` for each action you want to include.
For example, let's add two actions: "Accept" and "Reject".

```Swift theme={null}

// Add these lines inside your AppDelegate class, preferably below the existing extensions.

extension UNNotificationAction {
    static let accept = UNNotificationAction(
        identifier: "ACCEPT_ACTION",
        title: "Accept",
        options: [.foreground]
    )
    
    static let reject = UNNotificationAction(
        identifier: "REJECT_ACTION",
        title: "Reject",
        options: [.destructive, .foreground]
    )
}

```

2. Register Notification Category:

   You need to register the notification category with the actions you defined in your `didFinishLaunchingWithOptions` method:

   ```
   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
   // ... (your existing code)

   // Register notification category
   let acceptAction = UNNotificationAction.accept
   let rejectAction = UNNotificationAction.reject

   let messageCategory = UNNotificationCategory(
       identifier: "MESSAGE_CATEGORY",
       actions: [acceptAction, rejectAction],
       intentIdentifiers: [],
       options: []
   )

   UNUserNotificationCenter.current().setNotificationCategories([messageCategory])

   return true
   ```

}

````

3. Handle Action Taps:

Now, you need to handle the action taps in the `userNotificationCenter(_:didReceive response:)` method of your `AppDelegate`. 
You can check which action was tapped by inspecting the `response.actionIdentifier` property:

```Swift

func userNotificationCenter(_ center: UNUserNotificationCenter,
                            didReceive response: UNNotificationResponse) async {
    let userInfo = response.notification.request.content.userInfo

    if response.actionIdentifier == UNNotificationAction.accept.identifier {
        // Handle the "Accept" action
        print("User tapped Accept")
        // Perform the desired action for "Accept"
    } else if response.actionIdentifier == UNNotificationAction.reject.identifier {
        // Handle the "Reject" action
        print("User tapped Reject")
        // Perform the desired action for "Reject"
    } else {
        // Handle other actions or default behavior
        print("User tapped an action with identifier: \(response.actionIdentifier)")
    }
}

````

Your full `AppDelegate.swift` file should look like this:

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    let gcmMessageIDKey = "gcm.Message_ID"

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        FirebaseConfiguration.shared.setLoggerLevel(.min)

        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()
        
        // Register notification category
        let acceptAction = UNNotificationAction.accept
        let rejectAction = UNNotificationAction.reject
        
        let messageCategory = UNNotificationCategory(
            identifier: "MESSAGE_CATEGORY",
            actions: [acceptAction, rejectAction],
            intentIdentifiers: [],
            options: []
        )
        
        UNUserNotificationCenter.current().setNotificationCategories([messageCategory])
        
        // Messaging Delegate
        
        Messaging.messaging().delegate = self

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
      // Receive displayed notifications for iOS 10 devices.
      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  willPresent notification: UNNotification) async
        -> UNNotificationPresentationOptions {
        let userInfo = notification.request.content.userInfo

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // ...

        // Print full message.
        print(userInfo)

        // Change this to your preferred presentation option
        return [[.alert, .sound]]
      }

      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  didReceive response: UNNotificationResponse) async {
        let userInfo = response.notification.request.content.userInfo
          
          if response.actionIdentifier == UNNotificationAction.accept.identifier {
               // Handle the "Accept" action
               print("User tapped Accept")
               // Perform the desired action for "Accept"
           } else if response.actionIdentifier == UNNotificationAction.reject.identifier {
               // Handle the "Reject" action
               print("User tapped Reject")
               // Perform the desired action for "Reject"
           } else {
               // Handle other actions or default behavior
               print("User tapped an action with identifier: \(response.actionIdentifier)")
           }

        // ...

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // Print full message.
        print(userInfo)
          
          
      }
    
    func application(_ application: UIApplication,
                     didReceiveRemoteNotification userInfo: [AnyHashable: Any]) async
      -> UIBackgroundFetchResult {
      // If you are receiving a notification message while your app is in the background,
      // this callback will not be fired till the user taps on the notification launching the application.
      // TODO: Handle data of notification

      // With swizzling disabled you must let Messaging know about the message, for Analytics
      // Messaging.messaging().appDidReceiveMessage(userInfo)

      // Print message ID.
      if let messageID = userInfo[gcmMessageIDKey] {
        print("Message ID: \(messageID)")
      }

      // Print full message.
      print(userInfo)
          
          

      return UIBackgroundFetchResult.newData
    }

    
    }
    


extension AppDelegate: MessagingDelegate {
  
  func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
    print("Firebase registration token: \(String(describing: fcmToken))")
    
    let dataDict: [String: String] = ["token": fcmToken ?? ""]
    NotificationCenter.default.post(
      name: Notification.Name("FCMToken"),
      object: nil,
      userInfo: dataDict
    )
    // TODO: If necessary send token to application server.
    // Note: This callback is fired at each app startup and whenever a new token is generated.
  }
  
  
}

extension UNNotificationAction {
    static let accept = UNNotificationAction(
        identifier: "ACCEPT_ACTION",
        title: "Accept",
        options: [.foreground]
    )
    
    static let reject = UNNotificationAction(
        identifier: "REJECT_ACTION",
        title: "Reject",
        options: [.destructive, .foreground]
    )
}

```

Now, let’s trigger a notification with actionable buttons:

```JSON theme={null}

curl --location --request POST "https://api.novu.co/v1/events/trigger" \
     --header "Authorization: ApiKey 4de014990cfb201033014548be2db904" \
     --header "Content-Type: application/json" \
     --data-raw '{
    "name": "untitled",
    "to": {
        "subscriberId": "12345678"
    },
    "payload": {
        "title": "New Mission",
        "body": "Your mission, should you choose to accept it,"
    },
    "overrides": {
        "fcm": {
            "apns": {
                "payload": {
                    "aps": {
                        "category": "MESSAGE_CATEGORY"
                    }
                }
            }
        }
    }
}'

```

<Frame>
  <img />
</Frame>

## Additional resources

* [Generating a remote notification by Apple](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/generating_a_remote_notification)
* [Sending notification requests to APNs](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/sending_notification_requests_to_apns)


# How to Add Digest to Email Notifications
Source: https://v0.x-docs.novu.co/guides/add-digest-to-email-notifications

Leverage the digest functionality to send email notifications

# Introduction

In this guide, you’ll learn how to add digest functionality to email notifications. But before exploring the actual code, let’s understand what a digest notification is and how it works.

You can find the entire code(frontend as well as backend) for this app [here](https://github.com/novuhq/digest-email-app).

<Note>
  If, instead, you want to add digest to in-app notifications, we have a guide for that as well. Take a look [here](/guides/add-digest-to-inapp-notifications).
</Note>

### What is a Digest Notification?

Often when you associate notifications with user activity, the end user can be bombarded with messages because of the nature of the activity. Take for example the case of commenting in the context of a social media app. If you were to send a notification to a user for every comment they receive, and they happen to receive 100 comments, it could lead to user fatigue since you would have to send 100 messages.

This is where digest notifications come into the picture!

A digest notification is a notification that consolidates information from several notifications into one and delivers that notification to the end user instead of several separate messages.

### How does Digest Notification Work?

Novu has a built-in digest engine that collects multiple trigger events, aggregates them into a single message, and delivers it to the subscriber. You can use the digest engine by adding a ‘digest node’ to your workflow in the workflow editor in the [Novu dashboard](https://web.novu.co/workflows?utm_campaign=docs-digests). If you want to learn more about it, [this](/getting-started/concepts#digest) is a great place to start.

Let’s see it in action now!

# Add Digest Notification To An App

To get started with this, you need the following:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-digests) if you don’t have one yet.
* A working React development environment.

# Workflow setup in Novu

Once, you have these, follow the steps below:

1. Head over to the Novu Dashboard.
2. Click `Workflows` on the left sidebar of your Novu dashboard.
3. Click the `Create Workflow` button on the top right:

<Frame>
  <img />
</Frame>

Once you click the `create workflow` button, you’ll see a dropdown. Select `blank workflow` from the dropdown:

<Frame>
  <img />
</Frame>

You’ll now be taken to the workflow editor:

<Frame>
  <img />
</Frame>

Once here, you can add the channels you want to use for sending notifications and configure them. For this guide, we’ll use the `Email` channel. You’ll also see the `Digest` action on the right sidebar.

<Note>
  Each node that is added below the digest node will only be triggered after the specified time interval
</Note>

For example, in our case, say we want the email notification to be sent after every 6 hours. So, add the `digest` action below the `trigger node`, and add the `email` channel node below the `digest` node as shown below:

<Frame>
  <img />
</Frame>

The `digest` node allows you to set a specific time interval for when notifications should be sent:

<Frame>
  <img />
</Frame>

Once, you’ve configured it. Go ahead and configure the `email` channel as per your need:

<Frame>
  <img />
</Frame>

Here’s a brief explanation of all the options:

* **1-Preview:** This shows you a glimpse of what the email notification item will look like when delivered to the client.
* **2-Sender Name:** Lets you set the sender name for emails that the client will receive.
* **3-Subject:** This lets you define the subject line for the emails that the client will receive.
* **4-Filter:** This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.
* **5-Custom Code** - In custom code, you can write custom digest templates to show some/all parts of a message.
* **6-Test** - This allows you to send a test email to test if everything is working as per your wish.

You can write your own digest template in the 'custom code' section or just follow this guide as shown in the picture above. Once you’re done configuring this to your liking, click on the `update` button on the top right.

It’ll automatically create a trigger code that you can use in your app. To get it, click on the `get snippet` button on the top right and copy it:

<Frame>
  <img />
</Frame>

Now, let’s see how to add Novu to our app!

# Add Novu to the Backend and Configure it

In your backend, install the novu package using the following code:

```bash theme={null}
npm install @novu/node

```

Now, create a route that you want to hit when called from the front end. In our demo app, this is the route:

```jsx theme={null}
import express from 'express';

import { getEmailDigest } from '../controller/emaildigest.js';

const router = express.Router();

router.post('/sending-email-digest', getEmailDigest);

export default router;
```

Now, we need to write a controller function that will handle the logic for what is to be sent in the trigger function’s payload. In our case, this is the controller function:

```jsx theme={null}
import { sendEmailDigest } from '../novu/novu.js';

export const getEmailDigest = async (req, res) => {
  const { notif, email } = req.body;
  try {
    await sendEmailDigest(notif, email);
    res.status(201).json({ message: 'success', notif: notif });
  } catch (error) {
    res.status(409).json({ message: error.message });
  }
};
```

To make it modular, we’ll keep the trigger code in a separate function in a separate file (`novu.js`, in our case) and the trigger function is getting called in the controller function above by the name `getEmailDigest`.

If you’re following the guide, you’ve already copied the trigger function. But before we can add it to our app, we need one key thing - Subscribers.

Subscribers are users to which the notifications are sent. You can see a list of subscribers in the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-digests) as well.

In our app, we’ll create a subscriber in Node.js as we’re writing our backend in Node.js, but we also have backend [SDKs](/sdks/introduction) ([Node.js](https://github.com/novuhq/novu/tree/next/packages/node), [PHP](https://github.com/novuhq/novu-php), [.NET](https://github.com/novuhq/novu-dotnet), [Elixir](https://github.com/novuhq/novu-elixir), [Go](https://github.com/novuhq/go-novu), [Ruby](https://github.com/novuhq/novu-ruby), [Python](https://github.com/novuhq/novu-python), and [Kotlin](https://github.com/novuhq/novu-kotlin)) to choose from. The recommended way to create a subscriber in NodeJS is as follows:

```jsx theme={null}
await novu.subscribers.identify('digestEmailSub', {
  firstName: 'digest email subscriber',
  email: email,
});
```

Here, we’re creating a subscriber with the `subscriberID` of `digestEmailSub.` In most real-world scenarios, the `subscriberId` should be an alphanumeric entity like `adfa67y87ad0`. You can read more about subscribers [here](https://docs.novu.co/platform/subscribers/).

Back in our app, we can now add the trigger function:

```jsx theme={null}
import { Novu } from '@novu/node';

export const sendEmailDigest = async (notif, email) => {
  const novu = new Novu(process.env.YOUR_NOVU_API_KEY);
  await novu.subscribers.identify('digestEmailSub', {
    firstName: 'digest email subscriber',
    email: email,
  });

  novu.trigger('emaildigestworkflow', {
    to: {
      subscriberId: 'digestEmailSub',
      email: email,
    },
    payload: {
      notif: notif,
    },
  });
};
```

Now, we just need to hit the route defined above from the front end.

# Hit the backend route from the front end

From the front end, we just need to hit the route we had defined above. Below, I'm sharing the body component of the demo app I created to illustrate this:

```jsx theme={null}
const Body = () => {
  const [formInput, setFormInput] = useState({ notif: '', email: '' });
  const [buttonClicked, setButtonClicked] = useState(false);

  const onSubmitHandler = async (e) => {
    e.preventDefault();
    const response = await fetch(
      'https://emaildigestbackend.onrender.com/api/v1/sending-email-digest',
      {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(formInput),
      }
    );
    console.log(response.data);
    setFormInput({ notif: '' });
  };

  const handleClick = () => {
    setButtonClicked(true);

    // Reset the button feedback after a certain duration
    setTimeout(() => {
      setButtonClicked(false);
    }, 100);
  };

  const onChangeHandler = (e) => {
    const value = e.target.name === 'email' ? e.target.value.trim() : e.target.value;

    setFormInput((prev) => ({
      ...prev,
      [e.target.name]: value,
    }));
  };
  return (
    <div>
      <h1>Email Digest Playground</h1>
      <p>
        Don't know how to? Start{' '}
        <a className="underline" href="https://docs.novu.co/platform/digest/">
          {' '}
          here
        </a>
      </p>
      <form onSubmit={onSubmitHandler}>
        <div>
          <div>
            <label htmlFor="email" className="w-48">
              Email:
            </label>
            <input
              placeholder="Your Email here"
              value={formInput.email}
              id="email"
              name="email"
              onChange={onChangeHandler}
            />
          </div>
          <div>
            <label htmlFor="notif">Notification:</label>
            <textarea
              placeholder="Enter the notification text"
              value={formInput.notif}
              id="notif"
              name="notif"
              onChange={onChangeHandler}
            />
          </div>
        </div>

        <button onClick={handleClick} type="submit">
          <BiRightArrowAlt className="text-2xl" />
        </button>
      </form>
    </div>
  );
};
```

We're hitting the backend route we had created earlier. The backend has been deployed on render as can be seen in this code snippet above.

Congratulations on following the guide up until this point. We can style our app a little using [some TailwindCSS](https://github.com/novuhq/digest-email-app/blob/main/frontend/src/app.css).

If you’ve done everything as recommended, you’ll end up with an app that looks like this:

<Frame>
  <img />
</Frame>

In this app, when we enter the email id, some text in the input box, and click send, the notification appears in the inbox after the delay specified above (when we’re creating the workflow).

This is how we add digest to email notifications!


# How to Add Digest to In-App Notifications
Source: https://v0.x-docs.novu.co/guides/add-digest-to-inapp-notifications

Leverage the digest functionality to send in-app notifications

## Introduction

In this guide, you’ll learn how to add digest notifications to a React app. But before exploring the actual code, let’s understand what a digest notification is and how it works.

You can find the entire code(frontend as well as backend) for this app [here](https://github.com/novuhq/digest-learning-app/tree/main).

### What is a Digest Notification?

Often times when you associate notifications with user activity, the end user can be bombarded with messages because of the nature of the activity. Take for example the case of commenting in the context of a social media app. If you were to send a notification to a user for every comment they receive, and they happen to receive 100 comments, it could lead to user fatigue since you would have to send 100 messages.

This is where digest notifications come into the picture!

A digest notification is a notification that consolidates information from several notifications into one and delivers that notification to the end user instead of several separate messages.

### How does Digest Notification Work?

Novu has a built-in digest engine that collects multiple trigger events, aggregates them into a single message and delivers it to the subscriber. You can use the digest engine by adding a `digest node` to your workflow in the workflow editor in the [Novu dashboard](https://web.novu.co/workflows?utm_campaign=docs-digestsinapp).

Let’s see it in action now!

## Add Digest Notification To An App

To get started with this, you need the following:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-digestsinapp) if you don’t have one yet.
* A working React development environment.

## Workflow setup in Novu

Once, you have these, follow the steps below:

1. Head over to the Novu Dashboard.
2. Click `Workflows` on the left sidebar of your Novu dashboard.
3. Click the `Create Workflow` button on the top right:

<Frame>
  <img />
</Frame>

Once you click the `create workflow` button, you’ll see a dropdown. Select `blank workflow` from the dropdown:

<Frame>
  <img />
</Frame>

You’ll now be taken to the workflow editor:

<Frame>
  <img />
</Frame>

Once here, you can add the channels you want to use for sending notifications and configure them. For this guide, we’ll use the `In-App` channel. You’ll also see the `Digest` action on the right sidebar.

<Note>
  Each node that is added below the digest node will only be triggered after the specified time interval
</Note>

For example, in our case, say we want the In-App notification to be sent after every 6 hours. Next, add the `digest` action below the `trigger node`, and add the `in-app` channel node below the `digest` node as shown below:

<Frame>
  <img />
</Frame>

The `digest` node allows you to set a specific time interval for when notifications should be sent:

<Frame>
  <img />
</Frame>

Once, you’ve configured it. Go ahead and configure the `in-app` channel as per your need:

<Frame>
  <img />
</Frame>

Here’s a brief explanation of all the options:

* **1-Preview**: This shows you a glimpse of what each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.

In our case, we’re going to use the following:

<Frame>
  <img />
</Frame>

Once you’re done configuring this to your liking, click on the `update` button on the top right.
It’ll automatically create a trigger code that you can use in your app. To get it, click on the `get snippet` button on the top right and copy it:

<Frame>
  <img />
</Frame>

Now, let’s see how to add Novu to our app!

# Add Novu to the Backend and Configure it

In your backend, install the novu package using the following code:

```bash theme={null}
npm install @novu/node
```

Now, create a route which you want to hit when called from the front end. In our demo app, this is the route:

```jsx theme={null}
import express from 'express';
import { getDigest } from '../controller/digest.js';

const router = express.Router();

router.post('/sending-digest', getDigest);

export default router;
```

Now, we need to write a controller function that will handle the logic for what is to be sent in the trigger function’s payload. In our case, this is the controller function:

```jsx theme={null}
import { sendDigest } from '../novu/novu.js';

export const getDigest = async (req, res) => {
  const { name } = req.body;
  try {
    await sendDigest(name);
    res.status(201).json({ message: 'success', name: name });
  } catch (error) {
    res.status(409).json({ message: error.message });
  }
};
```

To make it modular, we’ll keep the trigger code in a separate function in a separate file (`novu.js`, in our case) and the trigger function is getting called in the controller function above by the name `getDigest`.

If you’re following the guide, you’ve already copied the trigger function. But before we can add it to our app, we need one key thing - **Subscribers.**

Subscribers are entities to which the notifications are sent. You can see a list of subscribers in the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-digests-inapp) as well.

In our app, we’ll create a subscriber in Node.js as we’re writing our backend in Node.js, but we also have backend [SDKs](/sdks/introduction) (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin) to choose from. The recommended way to create a subscriber in NodeJS is as follows:

```jsx theme={null}
await novu.subscribers.identify('aa234u787', {
  firstName: 'digest subscriber',
});
```

Here, we’re creating a subscriber with the `subscriberID` of `aa234u787.` You can read more about subscribers [here](/subscribers/subscribers).

Back in our app, we can now add the trigger function:

```jsx theme={null}
import { Novu } from '@novu/node';

export const sendDigest = async (name) => {
  const novu = new Novu(process.env.NOVU_API_KEY);

  await novu.subscribers.identify('aa234u787', {
    firstName: 'digest subscriber',
  });

  await novu.trigger('digest-showcase', {
    to: {
      subscriberId: 'aa234u787',
    },
    payload: {
      name: name,
    },
  });
};
```

Now, we just need to hit the route defined above from the front end and add Novu to it.

# Add Novu’s Notification Center to the front end

In the front end, install the Novu notification centre package using the following command:

```bash theme={null}
npm install @novu/notification-center

```

Now, import and render the component in your app. The code to do so is as follows:

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
  IMessage,
} from '@novu/notification-center';

function Header() {
  function onNotificationClick(message: IMessage) {
    // your logic to handle the notification click
    if (message?.cta?.data?.url) {
window.location.href = message.cta.data.url;
    }
  }

  return (
    <NovuProvider subscriberId={'USER_ID'} applicationIdentifier={'APP_ID_FROM_ADMIN_PANEL'}>
      <PopoverNotificationCenter onNotificationClick={onNotificationClick}>
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}

```

You can, of course, modify things as you need. For example, in our app, this is what we’ve done in the header:

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
} from '@novu/notification-center';
import '../css/Header.css';

const Header = () => {
  function onNotificationClick(message) {
    // your logic to handle the notification click
    if (message?.cta?.data?.url) {
window.location.href = message.cta.data.url;
    }
  }
  return (
    <div className="bell">
      <div className="intro">
        <h1 className="title">Play with the digest engine!</h1>
        <p className="desc">
          Don't know how to? Start <a href="https://docs.novu.co/platform/digest/">here</a>.
        </p>
      </div>
      <div className="center">
        <NovuProvider
          subscriberId={'aa234u787'}
          applicationIdentifier={process.env.REACT_APP_YOUR_APP_ID_FROM_ADMIN_PANEL}
        >
          <PopoverNotificationCenter onNotificationClick={onNotificationClick}>
            {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
          </PopoverNotificationCenter>
        </NovuProvider>
      </div>
    </div>
  );
};

export default Header;
```

You’ll also need to plug in your `applicationIdentifier`. You can get your `application id` from the settings menu in the Novu dashboard.

Beyond this, we just need to call the API we had written above when the form is submitted with the data we want in the payload. The code to do so is as follows:

```jsx theme={null}
import { useState } from 'react';
import axios from 'axios';
import '../css/Body.css';

const Body = () => {
  const [name, setName] = useState('');

  const onSubmitHandler = async (e) => {
    e.preventDefault();
    const res = await axios.post('http://localhost:3000/api/v1/sending-digest', { name });
    setName('');
  };
  const onChangeHandler = (e) => {
    setName(e.target.value);
  };
  return (
    <form onSubmit={onSubmitHandler} className="form">
      <label for="noti-text" className="label">
        Enter notification text:
      </label>
      <input
        id="noti-text"
        placeholder="Will be sent as a digest message"
        type="text"
        onChange={onChangeHandler}
        value={name}
        className="text"
      />
      <button className="btn" type="submit">
        {' '}
        Send{' '}
      </button>
    </form>
  );
};

export default Body;
```

The app is done now!

Congratulations for following the guide up until this point. We can style our app a little using [some CSS](https://github.com/novuhq/digest-learning-app/blob/main/frontend/src/App.css).

If you’ve done everything as recommended, you’ll end up with an app that looks like this:

<Frame>
  <img />
</Frame>

In this app, when we enter some text in the input box and click send, the notification appears in the bell icon after the delay specified above (when we’re creating the workflow).

This is how we add digest to in-app notifications!


# Recipes
Source: https://v0.x-docs.novu.co/guides/cookbook/introduction



This cookbook contains recipes and code samples demonstrating how to accomplish everyday tasks with Novu in your application. Each code example uses our libraries and SDKs.

<Frame>
  <img />
</Frame>

## Fetch Subscriber Feed

A subscriber feed is a list of all In-App messages for a single subscriber. It's a continuous stream of messages displayed in a list that subscribers can scroll through on the frontend via the Notification Center.

It is a dynamic list with **seen** and **unseen** capabilities. Multiple feeds can exist for a subscriber.

<Warning>**Subscriber Feed** is very different from **Activity Feed**. The former is for In-App channels, while the latter is a list of every message and relevant metadata across all channels shown in your dashboard.</Warning>

The code sample below fetches the list of all In-App messages sent to a specific subscriber:

<CodeGroup>
  ```javascript Node.js  theme={null}
  const { data: inAppMessages } = await novu.subscribers.getNotificationsFeed('subscriberId', {
    page: 0,
    limit: 10,

    // it is of type string. By default all feeds messages are fetched
    feedIdentifier: 'Marketing',

    // seen and read filter of type boolean
    seen: true,
    read: true
  });
  ```
</CodeGroup>

## Fetch All Feeds

In-App messages are grouped in Feeds. There can be one or multiple feeds.

The code sample below fetches all the feeds that have been created and exist in the In-App steps:

<CodeGroup>
  ```javascript Node.js  theme={null}
  const { data: feedsData } = await novu.feeds.get();
  ```
</CodeGroup>

## Delete a Message From a Feed

A message is a content sent to a single subscriber over a single channel. Some messages are simple, like SMS, while others have more features and capabilities, such as Email, Chat, In-App.

A single message can be deleted from a Feed. The code sample below shows how to do it:

<CodeGroup>
  ```javascript Node.js  theme={null}
  await novu.messages.deleteById('messageId');
  ```
</CodeGroup>

## Fetch all Messages Sent To All Subscribers

You can retrieve all messages sent to all subscribers. There are a couple of filters you can apply to fetch these messages.

* channel: fetches all messages that were sent via a specific channel, e.g Email, Sms, Push, In-App
* subscriberId: fetches all messages sent to a specific subscriber
* transactionIds: fetches all messages via transaction ids.

<CodeGroup>
  ```javascript Node.js  theme={null}
  import { ChannelTypeEnum } from '@novu/node';

  // All fields are optional
  const listMessagesOptions = {
    // pagination options
    page: 0,
    limit: 20,

    /**
     *  Filter options
     */
    // use ChannelTypeEnum.PUSH for push, ChannelTypeEnum.IN_APP for in-app,
    channel: ChannelTypeEnum.EMAIL, // only email type messages will be fetched
    subscriberId: '6444105141ffb0919496dfcb',
    transactionIds: ['644-41051-41ffb0-919496-dfcb'],
  };

  const { data: messagesData } = await novu.messages.list(listMessagesOptions);
  ```
</CodeGroup>

## Mark an In-App Message as Read/Seen

You can mark an In-App message as read/seen. Messages from other channels: **Email**, **Push**, **Chat**, **Sms** can't be marked as read/seen.

<CodeGroup>
  ```javascript Node.js  theme={null}
  const { data: markMessageAsRead } = await novu.subscribers.markMessageRead(
    'subscriberId',
    'messageId'
  );

  const { data: markMessageAsSeen } = await novu.subscribers.markMessageSeen(
    'subscriberId',
    'messageId'
  );
  ```
</CodeGroup>

## Mark an In-App Message as Read/Unread/Seen/Unseen

You can mark an In-App message as read/unread/seen/unseen. Messages from other channels: **Email**, **Push**, **Chat**, **Sms** can't be marked as read/unread/seen/unseen.

<CodeGroup>
  ```javascript Node.js  theme={null}
  const { data: markMessageAs } = await novu.subscribers.markMessageAs(
    'subscriberId',
    'messageId',
    { seen: true, read: false }
  );
  ```
</CodeGroup>

## Mark all In-App Messages as Read/Unread/Seen/Unseen

You can mark all In-App messages as read/unread/seen/unseen.

Messages from other channels: **Email**, **Push**, **Chat**, **Sms** can't be marked as read/unread/seen/unseen.

<CodeGroup>
  ```javascript Node.js  theme={null}
  import { MarkMessagesAsEnum } from "@novu/node"

  const { data: markAllInAppMessages } = await novu.subscribers.markAllMessagesAs(
     'subscriberId',

     // can be filtered with feed identifiers
     feedIdentifier: ['Marketing', 'Product']

     // MarkMessageAsEnum.READ => It will mark all messages as read
     // MarkMessageAsEnum.SEEN => It will mark all messages as seen
     // MarkMessageAsEnum.UNREAD => It will mark all messages as unread
     // MarkMessageAsEnum.UNSEEN => It will mark all messages as unseen
     markAs: MarkMessageAsEnum.Read
  );
  ```
</CodeGroup>

## Send Slack Notifications

You can send notifications to Slack Channels via Novu like so:

```javascript Node.js theme={null}
import {
  Novu,
  ChatProviderIdEnum
} from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

// Identify Subscriber
await novu.subscribers.identify('<SUBSCRIBER_ID>', {
  firstName: 'newSubForSlackChat',
});

// Set credentials for the Subscriber
await novu.subscribers.setCredentials('<SUBSCRIBER_ID>', ChatProviderIdEnum.Slack, {
  webhookUrl: "<WEBHOOK_URL>",
});

// Trigger slack notification
await novu.trigger('slack', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>'
  },
  payload: {
    chatMsg: '<INSERT_MESSAGE_CONTENT>'
  }
});
```

where `chatMsg` is a payload variable in the workflow editor.

Follow the [full guide](/guides/slack-guide) on how to send Slack notifications using Novu.


# Demo apps
Source: https://v0.x-docs.novu.co/guides/demos/introduction

Experience the power of Novu for triggering, digesting, and receiving notifications via different channels

### 1. Email, In-App Notification & Authentication

<Frame>
  <img />
</Frame>

<CardGroup>
  <Card title="Github" icon="github" href="https://github.com/novuhq/examples/tree/main/vue-nextjs-trigger-inapp-notifications">
    Find the source code here!
  </Card>

  <Card title="Demo" icon="play" href="https://novu-notifications-vue3.vercel.app/">
    Try it yourself first-hand!
  </Card>
</CardGroup>

### 2. Headless Notification Center

<Frame>
  <img />
</Frame>

<CardGroup>
  <Card title="Github" icon="github" href="https://github.com/novuhq/novu-headless-demo-app">
    Find the source code here!
  </Card>

  <Card title="Demo" icon="play" href="https://headlessdemo.vercel.app/">
    Try it yourself first-hand!
  </Card>
</CardGroup>

### 3. Notification Center

<Frame>
  <img />
</Frame>

<CardGroup>
  <Card title="Github" icon="github" href="https://github.com/novuhq/notification-center-demo">
    Find the source code here!
  </Card>

  <Card title="Demo" icon="play" href="https://notification-center-demo.vercel.app/">
    Try it yourself first-hand!
  </Card>
</CardGroup>

### 4. Email Digest Engine

<Frame>
  <img />
</Frame>

<CardGroup>
  <Card title="Github" icon="github" href="https://github.com/novuhq/digest-email-app">
    Find the source code here!
  </Card>

  <Card title="Demo" icon="play" href="https://emaildigest.vercel.app/">
    Try it yourself first-hand!
  </Card>
</CardGroup>

### 5. InApp Digest Engine

<Frame>
  <img />
</Frame>

<CardGroup>
  <Card title="Github" icon="github" href="https://github.com/novuhq/digest-learning-app">
    Find the source code here!
  </Card>

  <Card title="Demo" icon="play" href="https://digestplayground.vercel.app/">
    Try it yourself first-hand!
  </Card>
</CardGroup>


# How to use Novu to send notifications to a channel in a Discord server
Source: https://v0.x-docs.novu.co/guides/discord-guide

Learn to send Discord notifications swiftly with Novu

# Introduction

In this guide, you'll learn how to use Novu to send notifications to any channel in a Discord server. But before coding anything up, we just need to go over a couple of setup steps.
The corresponding docs for this guide are available on our [docs](https://docs.novu.co/channels-and-providers/chat/discord).
<Note>The entire code for this app is available on our [GitHub](https://github.com/novuhq/discord-chat-app).</Note>

So let's begin!

# Set up Discord

Setting up Discord is fairly straightforward. You just need the `webhook Url`. It is pretty simple and can be done in the following easy steps:

1. Go to the channel you want to add the webhook to (you need to be an admin of the discord server).

<Frame>
  <img />
</Frame>

2. Right-click the channel and select “Edit Channel”.

<Frame>
  <img />
</Frame>

3. Select Integrations -> Webhooks -> Create Webhook

<Frame>
  <img />
</Frame>

4. Edit the Bot name to your liking, copy the webhook URL and store it somewhere. We'll need it in the future.

<Frame>
  <img />
</Frame>

# Set up Novu

In this part, we'll set up a workflow that will be triggered when we send a notification. Workflows are like blueprints and hold the entire flow of notifications. You can read more about them on our [docs](https://docs.novu.co/workflows/notification-workflows). To set up a notification workflow for our app, follow these steps:

1. Make sure that you've set the Discord Integration as active from the [Novu Integrations Store](https://web.novu.co/integrations?utm_campaign=docs-discordnotifications).

<Frame>
  <img />
</Frame>

2. Goto the [Novu Web Dashboard](https://web.novu.co/workflows?utm_campaign=docs-discordnotifications).
3. Click on the 'Add a workflow' button and select 'Blank workflow' from the dropdown.

<Frame>
  <img />
</Frame>

4. Once there, give your workflow a name and drag and drop the 'chat' option below the 'workflow trigger' step.

<Frame>
  <img />
</Frame>

5. You can also add variables in the Workflow Editor. For example, here I've added 'chatMsg' as a variable as I'll be sending data using it.

<Frame>
  <img />
</Frame>

<Info>Whatever is placed inside double braces is a variable.</Info>
6\. Click the 'Get Snippet' button, copy the trigger code and keep it somewhere. We'll need this to trigger this workflow.

<Frame>
  <img />
</Frame>

Now, we've completed all the setup required and can move to coding!

# Create the backend

The backend for this app is quite simple. Simply install the Novu package:

```bash theme={null}
npm install @novu/node

```

Now, create a route that you'll hit when called from the front end. For our demo app, this is the route I've created:

```jsx theme={null}
import express from "express";
import { chatController } from "../controller/chat.js";

const router = express.Router();

router.post("/sendChat",chatController);

export default router;
```

Now, we need a controller function to handle what is to be sent in the trigger's function payload. Here's the controller I wrote:

```jsx theme={null}
import { chat } from "../novu/novu.js"

export const chatController = async (req, res) => {
    const { chatMsg } = req.body;
    try {
        await chat(chatMsg);
        res.status(201).json({ message: "Message sent successfully" });
    } catch (error) {
        console.log("notifController error:", error);
        res.status(500).json({ message: error.message })
    }
}
```

<Info>Notice how we're expecting 'chatMsg' in our payload. This is why we added it as a variable in the workflow created earlier.</Info>
To make it modular, we’ll keep the trigger code in a separate function in a separate file, `novu.js`, in our case, which is as follows:

```jsx theme={null}
import { Novu, ChatProviderIdEnum } from '@novu/node';

export const chat = async (chatMsg) => {
    try {
        const novu = new Novu(process.env.YOUR_NOVU_API_KEY_HERE);

        await novu.subscribers.identify(process.env.SUB_ID, {
            firstName: 'newSubForDiscordChat',
        });

        await novu.subscribers.setCredentials(process.env.SUB_ID, ChatProviderIdEnum.Discord, {
            webhookUrl: process.env.WEBHOOK_URL
        });

    } catch (error) {
        console.log(error);
    }
}
```

Add the trigger code you'd copied earlier:

```jsx theme={null}
import { Novu } from '@novu/node'; 

const novu = new Novu('<API_KEY>');

novu.trigger('chat-with-discord', {
    to: {
      subscriberId: '<REPLACE_WITH_DATA>'
    },
    payload: {
      chatMsg: '<REPLACE_WITH_DATA>'
    }
  });
```

Our final trigger code should look something like this:

```jsx theme={null}
import { Novu, ChatProviderIdEnum } from '@novu/node';

export const chat = async (chatMsg) => {
    try {
        const novu = new Novu(process.env.YOUR_NOVU_API_KEY_HERE);

        await novu.subscribers.identify(process.env.SUB_ID, {
            firstName: 'newSubForDiscordChat',
        });

        await novu.subscribers.setCredentials(process.env.SUB_ID, ChatProviderIdEnum.Discord, {
            webhookUrl: process.env.WEBHOOK_URL
        });

        await novu.trigger('chat-with-discord', {
            to: {
                subscriberId: process.env.SUB_ID
            },
            payload: {
                chatMsg: chatMsg
            }
        });
    } catch (error) {
        console.log(error);
    }
}
```

<Info>We're keeping all the sensitive data in a `.env` file to avoid hardcoding as a good practice</Info>

In this code snippet above, we're first initializing a new instance of Novu, then using it to 'identify' or [create](https://docs.novu.co/subscribers/subscribers#create-a-subscriber) a [subscriber](https://docs.novu.co/subscribers/subscribers).
<Info>The 'identify' method tries to find a subscriber with the given info. If it can't find any such subscriber, it creates a new subscriber with the supplied info.</Info>
After creating the subscriber, it runs the trigger code for the workflow we had created.

# Front end set up

For our demonstration purposes, the front-end is pretty basic. All we have to do is have an input field to take the notification text in and send the payload. The front-end code for this demo app is available on our [Github repo](https://github.com/novuhq/discord-chat-app/tree/main/frontend).
And here's our app in all its glory!

<Frame>
  <img />
</Frame>

This is how we send Discord notifications using Novu!


# How to send push notifications to Flutter apps (Android & iOS) with FCM using Novu
Source: https://v0.x-docs.novu.co/guides/fcm-flutter-novu/how-to-send-push-notifications-to-flutter-apps-with-fcm-using-Novu

Learn how to integrate Firebase Cloud Messaging with Novu and send notifications to Flutter apps

## Prerequisites

To complete this guide, you will need the following:

* [Apple Developer](https://developer.apple.com/) membership (to obtain the required permissions to send push notifications).
* A machine running MacOS to work on building the Flutter app for iOS devices.
* [Firebase](https://firebase.google.com/) account
* [Novu](https://web.novu.co/?utm_campaign=docs-gs-guides-fcm-flutter) account.
* [Android Studio](https://developer.android.com/studio/install) configured with Dart and Flutter plugins.
* [Xcode](https://developer.apple.com/xcode/) installed on your machine.

Check out the [Flutter app code for this guide on GitHub](https://github.com/novuhq/flutter-fcm-novu).

## Set up and Create a Flutter App

If you have an existing Flutter App, you can skip this step.

If you are creating a brand new Flutter app, please follow this [guide](https://firebase.google.com/codelabs/firebase-fcm-flutter#0).

## Set up Firebase and FlutterFire

Please follow this [guide to set up a Firebase project and integrate Firebase Cloud Messaging in your Flutter app](https://firebase.google.com/codelabs/firebase-fcm-flutter#2).

## Set Up Apple Integration

Please follow this [guide to ensure that everything is set up on your iOS device](https://firebase.flutter.dev/docs/messaging/apple-integration) to receive messages.

There is an optional section about allowing **Notification Images**. Follow the steps to install and activate the notification service extension. We'll need it later in this guide to display images as part of the push notifications from FCM.

## Set Up FCM Notification Permission & Registration Token

We'll add code to initialize Firebase and ask the user's permission to receive notifications.

Open up the `lib/main.dart` file in your Flutter app and replace everything with the code below:

```dart theme={null}
import 'package:flutter/foundation.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:flutter/material.dart';
import 'firebase_options.dart';
import 'package:firebase_messaging/firebase_messaging.dart'; // FlutterFire's Firebase Cloud Messaging plugin

// Add Stream controller
import 'package:rxdart/rxdart.dart';

// for passing messages from event handler to the UI
final _messageStreamController = BehaviorSubject<RemoteMessage>();

@pragma('vm:entry-point')
Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
  // If you're going to use other Firebase services in the background, such as Firestore,
  // make sure you call `initializeApp` before using other Firebase services.
  await Firebase.initializeApp();

  print("Handling a background message: ${message.messageId}");
  print('Message data: ${message.data}');
  print('Message notification: ${message.notification?.title}');
  print('Message notification: ${message.notification?.body}');

}

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );

  // Request permission
  final messaging = FirebaseMessaging.instance;

  // Web/iOS app users need to grant permission to receive messages
  final settings = await messaging.requestPermission(
    alert: true,
    announcement: false,
    badge: true,
    carPlay: false,
    criticalAlert: false,
    provisional: false,
    sound: true,
  );

  if (kDebugMode) {
    print('Permission granted: ${settings.authorizationStatus}');
  }

  // Register with FCM
  // It requests a registration token for sending messages to users from your App server or other trusted server environment.
  String? token = await messaging.getToken();

  if (kDebugMode) {
    print('Registration Token=$token');
  }

  // Set up foreground message handler
  FirebaseMessaging.onMessage.listen((RemoteMessage message) {
    if (kDebugMode) {
      print('Handling a foreground message: ${message.messageId}');
      print('Message data: ${message.data}');
      print('Message notification: ${message.notification?.title}');
      print('Message notification: ${message.notification?.body}');
    }

    _messageStreamController.sink.add(message);
  });

  // Set up background message handler
  FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);

  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const MyHomePage(title: 'Flutter Demo Home Page'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({Key? key, required this.title}) : super(key: key);

  final String title;

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  String _lastMessage = "";

  _MyHomePageState() {
    _messageStreamController.listen((message) {
      setState(() {
        if (message.notification != null) {
          _lastMessage = 'Received a notification message:'
              '\nTitle=${message.notification?.title},'
              '\nBody=${message.notification?.body},'
              '\nData=${message.data}';
        } else {
          _lastMessage = 'Received a data message: ${message.data}';
        }
      });
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            Text('Last message from Firebase Messaging:',
                style: Theme.of(context).textTheme.titleLarge),
            Text(_lastMessage, style: Theme.of(context).textTheme.bodyLarge),
          ],
        ),
      ),
    );
  }
}
```

*lib/main.dart*

There are 4 sections to pay attention to:

<Steps>
  <Step title="The Request permission code block">
    This shows the notification permission prompt to the user when the user interacts with the app for the first time. If the user allows it, then we can get a token.

    ```dart theme={null}
    // Request permission
    final messaging = FirebaseMessaging.instance;

    // Web/iOS app users need to grant permission to receive messages
    final settings = await messaging.requestPermission(
      alert: true,
      announcement: false,
      badge: true,
      carPlay: false,
      criticalAlert: false,
      provisional: false,
      sound: true,
    );
    ```
  </Step>

  <Step title="Registering and obtaining the FCM token for the device">
    A device's token is needed for the specific device to receive messages. The `getToken()` returns the registration token for the app instance on the device.

    ```dart theme={null}
      String? token = await messaging.getToken();

      if (kDebugMode) {
        print('Registration Token=$token');
      }
    ```
  </Step>

  <Step title="The foreground message handler">
    This handler listens to when a push notification is sent from FCM to the device. If the app is in the foreground, then it prints out the notification title, body, messageId, and data properties to the console.

    ```dart theme={null}
      FirebaseMessaging.onMessage.listen((RemoteMessage message) {
        if (kDebugMode) {
          print('Handling a foreground message: ${message.messageId}');
          print('Message data: ${message.data}');
          print('Message notification: ${message.notification?.title}');
          print('Message notification: ${message.notification?.body}');
        }

        _messageStreamController.sink.add(message);
      });
    ```
  </Step>

  <Step title="The background message handler">
    This handler listens to when a push notification is sent from FCM to the device. If the app is in the background, then it prints out the notification title, body, messageId, and data properties to the console.

    ```dart theme={null}
      ...
      @pragma('vm:entry-point')
      Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
        // If you're going to use other Firebase services in the background, such as Firestore,
        // make sure you call `initializeApp` before using other Firebase services.
        await Firebase.initializeApp();

        print("Handling a background message: ${message.messageId}");
        print('Message data: ${message.data}');
        print('Message notification: ${message.notification?.title}');
        print('Message notification: ${message.notification?.body}');

      }
      ...


      FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);
    ```
  </Step>
</Steps>

Now, run the Flutter app. Your device should be connected to your machine to enable the app to run on it.

<Frame>
  <img />
</Frame>

<br />

<Frame>
  <img />
</Frame>

<br />

<Frame>
  <img />
</Frame>

## Cloud Message Test

In your Firebase project, navigate to `Engage` section and click on `Messaging`.

<Frame>
  <img />
</Frame>

Click on `Create your first campaign` and select `Firebase Notification messages`.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Enter the `Notification title` and the `Nabigateotification text`, and click on `Send test message`.

<Frame>
  <img />
</Frame>

We must copy and paste this FCM registration token to confirm our device. You can find it logged as shown earlier in our editor.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Click on 'Test'.

<Frame>
  <img />
</Frame>

You should see the notification on your device!

<Frame>
  <img />
</Frame>

## Sign Up on Novu

Let's use Novu to fire push notifications via FCM. First, sign up on [Novu Cloud](https://web.novu.co)?utm\_campaign=docs-gs-guides-fc-flutter.

<Frame>
  <img />
</Frame>

Next, immediately configure FCM as a Push channel provider.

<Frame>
  <img />
</Frame>

You can also do this by heading straight to the `Integrations Store`. Click on `Add a provider`.

## Connect  FCM as a Push Channel provider

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

You only need to configure FCM with Novu with the Firebase Service Accounts private key.

To acquire the account key JSON file for your service account, follow this instructions:

1. Select your project. Click the gear icon on the top of the sidebar.
2. Head to project settings.
3. Navigate to the `Service accounts` tab.
4. Click `Generate new private key`, then confirm by clicking `Generate key`.
5. Click `Generate key` to download the JSON file.
6. Once the file is on your machine, paste the entire JSON file content in the `Service Account` field of the FCM provider in the Integration store on Novu’s web dashboard.

Make sure your service account key JSON content contains these fields:

```JSON theme={null}

{
  "type": "service_account",
  "project_id": "PROJECT_ID",
  "private_key_id": "PRIVATE_KEY_ID",
  "private_key": "PRIVATE_KEY",
  "client_email": "FIREBASE_ADMIN_SDK_EMAIL",
  "client_id": "CLIENT_ID",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "CLIENT_X509_CERT_URL"
}

```

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Create a Notification Workflow

In Novu, creating a workflow means establishing a blueprint for sending notifications within your app. This unified structure ties together email, in-app messages, SMS, push notifications, and chat into **one entity**.

Each workflow has a unique name and identifier and includes customized content for various channels, using `{{handlebars}}` variables for personalization.

This ensures consistent platform notifications and allows dynamic adjustments for individual subscribers, scenarios, and use cases.

<Steps>
  <Step title="Navigate to 'Workflows' tab and click on 'Blank Workflow'">
    <Frame>
      <img />
    </Frame>

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Add (Drag & Drop) the Push channel node to the workflow">
    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Click on the node, and start to modify the content. Add a title and content. Once you are done, click on 'Update'">
    <Frame>
      <img />
    </Frame>
  </Step>
</Steps>

We need to fire notifications to subscribers. So, let's create a subscriber!

## Create A Subscriber & Update Credentials

A subscriber is essentially the recipient of the notifications sent through Novu's system. When you create a subscriber, you're setting up the necessary information for Novu to send targeted notifications to that individual.

You can see the list of subscribers in the `Subscribers` section of the Novu dashboard.

<Frame>
  <img />
</Frame>

<Steps>
  <Step title="Create a subscriber">
    ```JSON theme={null}

    curl --location 'https://api.novu.co/v1/subscribers' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <YOUR_API_KEY>' \
    --data-raw '{
    "subscriberId": "584349343",
    "firstName": "Flutter",
    "lastName": "Boy",
    "email": "flutterboy@gmail.com",
    }'

    ```

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Grab the FCM device token from your Editor log">
    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Add Device Tokens to Subscriber by Updating Subscriber Credentials">
    <Note> Subscriber can have multiple device tokens </Note>

    Here, you can locate the Provider\_Identifier.

    <Frame>
      <img />
    </Frame>

    ```JSON theme={null}

      curl --request PUT \
          --url https://api.novu.co/v1/subscribers/{subscriber_id}/credentials \
          --header 'Content-Type: application/json' \
          --header 'Authorization: ApiKey <YOUR_API_KEY>' \
          --data '{
              "credentials":{
                "deviceTokens": ["<insert-fcm-token>"]
            },
            "integrationIdentifier":"<Provider_Identifier>",
            "providerId":"fcm"
      }'

    ```

    *Update the Subscriber Credentials by adding the device tokens to the subscriber*
  </Step>
</Steps>

## Sending a Push Notification to a Device(Android/iOS) with Novu

To send a notification with Novu, you are actually triggering a notification workflow.
You have the ability to test the trigger using the Novu UI or by calling Novu's API.

**Trigger a workflow via the API**

Insert the `trigger identifier` as the name in the API request below:

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "<REPLACE_WITH_DATA>"
         },
         "payload": {}
       }'

```

**Trigger a workflow via the Novu Dashboard**

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

**Receive Triggered Push Workflow on Device**

<Frame>
  <img />
</Frame>

## Dynamic Content

When we were creating the first workflow, we "Hardcoded" the content of the notification.

Now, we will determine the content when calling the API.

1. In the workflow, we should change the values of the `title` and the `body` to `{{title}}` and `{{body}}`.
   That way, we could insert values through the payload of the API call.

<Frame>
  <img />
</Frame>

2. Add a `payload` object to the API call.

Insert the `trigger identifier` as the name in the API request below:

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "This title was set via the Payload",
           "body": "This body was set via the Payload"
         },
       }'

```

<Frame>
  <img />
</Frame>

## Handling Data Type Messages

With FCM, you can send `Notification` and `Data` messages. We have handled sending notification messages. Let's handle data messages.

Data messages contain user-defined custom key-value pairs. The information is encapsulated in the `data` key. The app can do whatever it pleases with the data once it's received by the device.

**Via the Trigger API call**

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "This title was set via the Payload",
           "body": "This body was set via the Payload"
         },
         "overrides": {
          "fcm": {
            "data": {
              "subscription_status": "active",
              "renewed_by": "bisola"
            }
          }
         }
       }'

```

<Frame>
  <img />
</Frame>

## Sound of a notification

You can use the name of a sound file in your app's main bundle or in the Library/Sounds folder of your app's container directory.

Specify the string "default" to play the system sound. Use it for regular notifications. For critical alerts, use the sound dictionary instead.

The code below works for iOS devices:

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "Notification With Sound",
           "body": "Hello World from Novu"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "payload": {
                 "aps": {
                   "sound": "default" // configure sound to the notification
                 }
               }
             }
           }
         }
       }'

```

For Android devices, use the following:

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "Notification With Sound",
           "body": "Hello World from Novu"
         },
         "overrides": {
           "fcm": {
             "android": {
               "notification": {
                 "defaultSound": true // This uses the Android framework's default sound for the notification.
               }
             }
           }
         }
       }'

```

## Priority for notification

If you omit this header, APNs (iOS) set the notification priority to `10`.

* Specify `10` to send the notification immediately.
* Specify `5` to send the notification based on power considerations on the user’s device.
* Specify `1` to prioritize the device’s power considerations over all other factors for delivery and prevent awakening the device.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "apns-priority: 5",
           "body": "Novu's API"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "headers": {
				          "apns-priority":"5" //priority for notifications
			          },
               "payload": {
                 "aps": {}
               },
               "fcm_options": {}
             }
           }
         }
       }'

```

For Android devices, specify `high` or `normal` for the priority of the notification message.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "novu-push-workflow-for-flutter",
         "to": {
           "subscriberId": "584349343"
         },
         "payload": {
           "title": "priority",
           "body": "Novu's API"
         },
         "overrides": {
           "fcm": {
             "android": {
               "priority": "high"
             }
           }
         }
       }'

```

## Sending Push Notification With Image

Up to this point, your notifications have all contained only text. But if you’ve received many notifications, you know that notifications can have rich content, such as images. It’d be great if your notifications showed users a nice image related to their content. Once again, Firebase makes this super simple.

To show an image in push notifications, you’ll need to create a ***Notification Service Extension***. We handled it earlier in this guide during the Apple setup.

For reiteration, follow [this guide](https://firebase.flutter.dev/docs/messaging/apple-integration#advanced-optional-allowing-notification-images) to ensure it is properly set up for iOS devices.

When making the API call, we should include:

* "mutable-content": 1 inside the “aps” object.
* "image" in "fcm\_options" object,
* URL address of the image.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "This is a notification with an image",
           "body": "Check this out"
         },
         "overrides": {
           "fcm": {
             "apns": {
                "payload": {
                  "aps": {
                    "mutable-content": 1
                  }
                },
                "fcm_options": {
                  "image": "https://www.planetware.com/wpimages/2020/02/france-in-pictures-beautiful-places-to-photograph-eiffel-tower.jpg"
                  }
            }
          }
        }
    }'
```

## Additional resources

* [Notifications Usage - Flutter Fire](https://firebase.flutter.dev/docs/messaging/notifications)


# How to batch product notifications via code
Source: https://v0.x-docs.novu.co/guides/framework-guides/digest

Leverage Novu's Digest Engine to batch product notifications

# Introduction

Learn how to use Novu’s Digest engine to batch notifications. In this guide, you’ll learn how to aggregate multiple messages and send them off as one notification. Follow these steps:

## Getting started

Integrating Novu’s code-first workflow with React.Email for your Next.js application can be done in three steps

1. Create a fully-featured Novu NextJS app with the command below:

```bash theme={null}
npx create-novu-app
```

1. Once this installation is complete, simply `cd` into the directory and start your app using the `npm run dev` command.

Now, we’re all set to send digested notifications but before we do, let’s look at what it is and how it works:

## Digest engine and how it works

Novu’s Digest Engine is designed to consolidate multiple trigger events into a single cohesive message before delivering it to the subscriber. This functionality is essential for managing notification overload and ensuring that users receive meaningful, aggregated updates rather than being bombarded with numerous individual notifications. Here’s how it works:

1. **Event Accumulation**: The digest engine collects multiple trigger events based on a unique `subscriberId` to be delivered as one message.
2. **Batching Events**: The engine batches these events within a specified time interval. This interval can be configured in units of seconds, minutes, hours, days, weeks, or months.
3. **Delivery**: After the accumulation period, the batched events are sent out as a single notification. This consolidated message reduces the frequency of notifications and provides the user with a summary of all relevant events.

## How to digest in a code-first workflow:

1. Write a workflow and add a digest node to it:

```tsx theme={null}
import { Client } from "@novu/framework";

export const client = new Client({
  apiKey: '<YOUR_NOVU_API_KEY>',
  /**
   * Enable this flag only during local development
   */
  strictAuthentication: process.env.NODE_ENV !== "development",
});

export const digestWorkflow = workflow('novu-digest',
  
  async ({ step, payload }) => {
  
    // Add Digest Node
    const digestResult = await step.digest('email-digest', async () => ({
      unit: 'seconds',
      amount: 30,
    }));

    // Send a welcome email
    await step.email('send-email', () => {
      const resObj = {
        subject: `Welcome to Novu`,
        body: (digestResult.events.map((event) => event.payload.text).join('\n')),
      }
      return resObj
    });
  },
  {
    payloadSchema: {
      properties: {
        email: { type: 'string' },
        text: { type: 'string', default: 'Sumit' },
      },
      required: ['text'],
    },
  }
);

```

<Info>
  💡 In the digest node above, you can change the digest duration by setting a value to the key `amount` and changing the value of `unit` to seconds, minutes, hours, days, weeks, or months
</Info>

2. Here’s a simple client-side app with a handler function attached to the `submit` event:

```tsx theme={null}
"use client"
import React, { useState } from "react";

export default function Home() {

  const [email, setEmail] = useState('')
  const [text, setText] = useState('')

  const onClickHandler = async (e: React.FormEvent<HTMLFormElement>) => {
    try {
      e.preventDefault();
      await fetch("/api/users", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          email: email,
          text: text,
        }),
      });

      // console.log('working fine');
    } catch (error) {
      console.error('Error:', error);
    }
  };
  return (
    <main style={{ height: '100vh', display: 'flex', justifyContent: 'center', alignItems: 'center' }}>
      <form onSubmit={(e) => onClickHandler(e)}>
        <input
          placeholder="Enter email id"
          onChange={(e) => setEmail(e.target.value)}
          style={{
            // Add your CSS-in-JS styles here
            padding: '0.5rem',
            marginBottom: '1rem',
            borderRadius: '0.25rem',
            border: '1px solid #ccc',
            width: '100%',
            boxSizing: 'border-box',
          }}
        />
        <input
          placeholder="Enter the notification text"
          onChange={(e) => setText(e.target.value)}
          style={{
            // Add your CSS-in-JS styles here
            padding: '0.5rem',
            marginBottom: '1rem',
            borderRadius: '0.25rem',
            border: '1px solid #ccc',
            width: '100%',
            boxSizing: 'border-box',
          }}
        />
        <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'center' }}>

          <button
            style={{
              // Add your CSS-in-JS styles here
              padding: '0.5rem 1rem',
              backgroundColor: '#4CAF50',
              color: 'white',
              border: 'none',
              borderRadius: '0.25rem',
              cursor: 'pointer',
            }}
          >
            Submit
          </button>
        </div>
      </form>
    </main>
  );
}

```

3. And the corresponding route that it hits once the event fires:

```tsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<YOUR_NOVU_API_KEY>');

export async function POST(request: Request) {
    const res = await request.json();

    await novu.trigger('novu-digest', {
        to: {
            subscriberId: 'novu-sub-digest',
        },
        payload: {
            email: res.email,
            text: res.text
        },
    });

    console.log('triggered')
    return Response.json({ success: true });
}

```

That’s it!

That’s how simple it is to use Novu’s Digest Engine. Digesting notifications enhances the user experience by providing comprehensive summaries, making it easier for users to stay informed about important updates in a concise manner, without straining users with too many notifications. We have got a thorough guide on digesting notifications [in our docs](https://docs.novu.co/guides/add-digest-to-email-notifications) that you can check out as well.


# How to send notifications with Next.js and MJML
Source: https://v0.x-docs.novu.co/guides/framework-guides/framework-mjml

Leverage MJML package to send email notifications

# Introduction

This guide will walk you through how to send notifications with MJML and Novu. You can check out the code for a [sample demo app](https://github.com/novuhq/framework-mjml).

## Pre-requisites

* A Novu account
* Node installed on your machine
* A working NextJS development environment

## Get started with Novu Framework

[Novu Framework](https://docs.novu.co/framework/quickstart) is a "notifications as code" approach that enables developers to define workflows as functions and integrate them with their preferred libraries for email, SMS, and chat generation.

1. To get started with Novu Framework, just run this command in your terminal, it’ll scaffold a new NextJS project with Novu Framework and we’ll be ready to roll!

```jsx theme={null}
npx create-novu-app --api-key=<YOUR_API_KEY>

```

2. Once you execute this command, you’ll be asked to give your project a name. I’ll keep the default `my-novu-app` but you can choose your own.

<Frame>
  <img />
</Frame>

3. You’ll then be asked if you want to use React-email or not. Since, we’ll be using MJML, I’m choosing the default 'No' option.

<Frame>
  <img />
</Frame>

4. After this step, all the dependencies will be installed and you will be able to start using Novu Framework.

<Frame>
  <img />
</Frame>

5. Once this installation is complete, simply cd into the directory and start your app using the `npm run dev` command, and your app will be served on `localhost:4000`

<Note>
  Make sure that the port 4000 isn’t already being used!
</Note>

You’ll now have a NextJS app running on `http://localhost:4000` and you can make changes to your app as you see fit. Let’s now move to the meaty stuff - using Novu Framework in a NextJS app and the magic of Dev Studio.

## Echo Dev Studio

The Echo Dev Studio is a companion app to the Echo Client SDK. Its goal is to provide a local environment that lives near your code.

To launch the dev studio locally you can run: `npx novu-labs@latest echo`. The Dev Studio will be started by default on port `2022`, and accessible via: `http://localhost:2022`

<Frame>
  <img />
</Frame>

Here’s how the Dev Studio looks on the first run:

<Frame>
  <img />
</Frame>

You’ll notice that it asks for an `Echo endpoint` at the bottom. Novu Echo requires a single HTTP endpoint (`/api/echo` or similar) to be exposed by your application. This endpoint is used to receive events from our Worker Engine. We have more on Novu endpoint [in our docs.](https://docs.novu.co/framework/concepts/endpoint)

<Note>
  You can view the Echo Endpoint as a webhook endpoint that Novu will call when it needs to retrieve contextual information for a given subscriber and notification.
</Note>

Just enter the full URL of your Echo Endpoint. In our case, it is `http://localhost:4000/api/echo`

<Frame>
  <img />
</Frame>

Once you do, you’ll see a green checkmark alongside the URL input box and a green `connected` highlight at the top right corner.

## Installing and configuring MJML

Integrating MJML with Novu in our NextJS app is quite straightforward, with just one small caveat. Following are the steps to get it installed and configured:

1. Simply run the following command to install it like any other npm package:

```bash theme={null}
npm i mjml
```

<Warning>
  Once installed, you need to keep in mind that, MJML doesn’t play very nice with newer web technologies such as Next.js that we’re using today. In order to overcome some hurdles, we need to use the `require` statement when importing MJML in our files, such as when defining the template.
</Warning>

2. To write an email template, you can look over some of the examples in the MJML documentation to get inspiration from. In our case, this is the template:

```jsx theme={null}
// notice the use of require statement here:
const mjml2html = require("mjml")

export const mjmlTemplate = (inputs: Inputs) => {
    const { text, buttonText, imageUrl, buttonUrl } = inputs;
    return (mjml2html(`
    <mjml>
    <mj-body background-color="#d7dde5">
      <mj-section full-width="full-width">
        <mj-column width="66.66666666666666%" vertical-align="middle">
          <mj-text align="left" font-size="11px" padding-bottom="0px" padding-top="0"><span style="font-size: 11px">${text}</span></mj-text>
        </mj-column>
        <mj-column width="33.33333333333333%" vertical-align="middle">
          <mj-text align="right" font-size="11px" padding-bottom="0px" padding-top="0"><span style="font-size: 11px"><a href="${buttonUrl}" style="text-decoration: none; color: inherit;">OnePage</a></span></mj-text>
        </mj-column>
      </mj-section>
      <mj-section background-color="#ffffff" full-width="full-width">
        <mj-column width="33.33333333333333%" vertical-align="middle">
          <mj-image src="http://191n.mj.am/img/191n/1t/hx.png" alt="OnePage" padding-bottom="0px" padding-top="10px"></mj-image>
        </mj-column>
        <mj-column width="66.66666666666666%" vertical-align="middle">
          <mj-text align="center" padding-bottom="0px" padding-top="10px"><a href="${buttonUrl}" style="text-decoration: none; color: inherit;">Home</a>&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;<a href="${buttonUrl}" style="text-decoration: none; color: inherit;">Features</a>&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;
            <a href="${buttonUrl}" style="text-decoration: none; color: inherit;">Portfolio</a>
          </mj-text>
        </mj-column>
      </mj-section>
      <mj-section background-url="${imageUrl}" vertical-align="middle" background-size="cover" full-width="full-width" background-repeat="no-repeat">
        <mj-column width="100%" vertical-align="middle">
          <mj-text align="center" font-size="14px" color="#45474e" padding-bottom="10px" padding-top="45px"><span style="font-size: 30px; line-height: 30px;">More than an email template</span><br /><br />Only on <span style="color: #e85034">Mailjet</span> template builder</mj-text>
          <mj-button align="center" background-color="#e85034" color="#fff" border-radius="24px" href="${buttonUrl}" font-family="Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif" padding-bottom="45px" padding-top="10px">${buttonText}</mj-button>
        </mj-column>
      </mj-section>
      <mj-section background-color="#ffffff" vertical-align="top" full-width="full-width">
        <mj-column vertical-align="top" width="33.33333333333333%">
          <mj-image src="http://191n.mj.am/img/191n/1t/hs.png" alt="" width="50px"></mj-image>
          <mj-text align="center" color="#9da3a3" font-size="11px" padding-bottom="30px"><span style="font-size: 14px; color: #e85034">Best audience</span><br /><br />Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque eleifend sagittis nunc, et fermentum est ullamcorper dignissim.</mj-text>
        </mj-column>
        <mj-column vertical-align="top" width="33.33333333333333%">
          <mj-image src="http://191n.mj.am/img/191n/1t/hm.png" alt="" width="50px"></mj-image>
          <mj-text align="center" color="#9da3a3" font-size="11px" padding-bottom="30px"><span style="font-size: 14px; color: #e85034">Higher rates</span><br /><br />Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque eleifend sagittis nunc, et fermentum est ullamcorper dignissim.</mj-text>
        </mj-column>
        <mj-column vertical-align="top" width="33.33333333333333%">
          <mj-image src="http://191n.mj.am/img/191n/1t/hl.png" alt="" width="50px"></mj-image>
          <mj-text align="center" color="#9da3a3" font-size="11px" padding-bottom="30px" padding-top="3px"><span style="font-size: 14px; color: #e85034">24/7 Support</span><br /><br />Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque eleifend sagittis nunc, et fermentum est ullamcorper dignissim.</mj-text>
        </mj-column>
      </mj-section>
      <mj-section background-color="#e85034" vertical-align="middle" full-width="full-width">
        <mj-column width="100%" vertical-align="middle">
          <mj-text align="center" color="#ffffff" font-size="18px" padding-bottom="10px">Why choose us?</mj-text>
          <mj-divider border-color="#fff" border-style="solid" border-width="1px" padding-left="100px" padding-right="100px" padding-bottom="20px" padding-top="20px"></mj-divider>
          <mj-text align="center" color="#f8d5d1" font-size="11px" padding-bottom="25px">Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris. Lorem ipsum dolor sit amet, consectetur adipiscing
            elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris.</mj-text>
        </mj-column>
      </mj-section>
      <mj-section vertical-align="middle" background-color="#ffffff" full-width="full-width">
        <mj-column width="50%" vertical-align="middle">
          <mj-image src="http://191n.mj.am/img/191n/1t/h2.jpg" alt="" padding-bottom="20px" padding-top="20px"></mj-image>
        </mj-column>
        <mj-column width="50%" vertical-align="middle">
          <mj-text align="left" color="#9da3a3" font-size="11px" padding-bottom="25px" padding-top="25px"><span style="font-weight: bold; font-size: 14px; color: #45474e">Great newsletter for the best company out there</span><br /><br />Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna
            aliqua. Ut enim ad minim veniam.</mj-text>
          <mj-button align="left" background-color="#e85034" color="#fff" border-radius="24px" font-size="11px" href="${buttonUrl}" font-family="Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif" padding-bottom="45px" padding-top="10px">READ MORE</mj-button>
        </mj-column>
      </mj-section>
      <mj-section full-width="full-width">
        <mj-column width="100%" vertical-align="middle">
          <mj-text align="center" font-size="11px" padding-bottom="0px" padding-top="0px">
          <p style="font-size: 11px">
          Please contact us if you have any questions. 
          </mj-text>
        </mj-column>
      </mj-section>
    </mj-body>
  </mjml>
    `));
}
```

3. And as final step, we need to define the workflow that uses the template defined above.

```jsx theme={null}
import { Client, workflow } from "@novu/framework";
import { mjmlTemplate } from "./mjml";

export const client = new Client({
  apiKey: process.env.NOVU_API_KEY,
  strictAuthentication: process.env.NODE_ENV !== "development",
});

export const emailWorkflow = workflow('mjml-email-workflow', async ({ payload, step }) => {
  await step.email('send-email', async (inputs) => {
    return {
      subject: `Welcome to MJML with Novu Framework, ${payload.text}!`,
      body: mjmlTemplate(inputs).html,
    };
  }, {
    inputSchema: {
      type: 'object',
      properties: {
        text: { type: 'string', default: 'Welcome to our service' },
        imageUrl: { type: 'string', default: 'https://picsum.photos/id/11/2000/300' },
        buttonText: { type: 'string', default: 'Sign up' },
        buttonUrl: { type: 'string', default: 'https://novu.co' },
      },
      additionalProperties: false,
    } as const
  });
}, {
  payloadSchema: {
    properties: {
      text: { type: 'string', default: 'Sumit' },
    },
    additionalProperties: false,
  }
});
```

Once you do this, you’ll see this workflow, the steps in the workflow, step inputs, payload variables and the rendered view of this workflow on the Echo Dev Studio:

<Frame>
  <img />
</Frame>

Here, from the Dev Studio, you or your peers can change things like the text of a button, toggle visibility of a button, static text content etc and have it synced with the cloud with the `Sync to Cloud` button.

### Payload vs Step Inputs

Notice that in the Echo dev studio above, we’ve used payload as well as step inputs. Here’s how you can decide if you need either or both:

| Payload                                                                                                                               | Step Inputs                                                                                                                                                                             |
| ------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| is used for dynamic content that changes from one notification to another based on events occurring in your system.                   | are used for static elements or predefined options that non-technical team members can modify without altering the codebase.                                                            |
| is controlled by developers and passed dynamically through the novu.trigger method.                                                   | are defined by developers but aremeant to be utilized and modified by non-technical peers.                                                                                              |
| Payload examples include User ID, Post ID, Comment, Order ID, 2FA token, etc., which are likely to change with each notification.     | Step Inputs examples include the text of a button, whether a section should be shown, static text content, etc., which are generally static but configurable elements.                  |
| Payload modifications are made in the code by developers at the time of triggering a notification.                                    | Step Inputs can be modified directly in the UI, offering a no-code solution for non-technical team members to make changes.                                                             |
| Payload data is passed during the novu.trigger method and is part of the dynamic data handling process within notification workflows. | Step Inputs are predefined in the workflow configuration and can be adjusted through the Echo Dev Studio, affecting how notifications are rendered without changing the workflow logic. |

## Syncing with the cloud, with the click of a button

Once done with the workflow, now we need to sync it to the cloud. Fortunately, Novu Framework makes it a breeze to sync changes from the local machine to the cloud and it all happens with a click of a button.

To enable our cloud environment to talk to your local Bridge instance, you need to supply an Bridge endpoint URL. This sets up a communication channel between our cloud environment and your local instance. To allow Novu to communicate with your local machine a tunnel will need to be generated.

The `create-novu-app` command sets up `localtunnel` for you. Running the `npm run dev` script in the project launches both the Bridge application and the tunnel solution. The tunnel URL shows up in the console output.

You can also use a tool like `ngrok`:

```bash theme={null}
// using ngrok 
ngrok http http://localhost:<YOUR_EDGE_PORT>      
```

In our case, the app is running on port 4000 so we’ll use:

```bash theme={null}
ngrok http http://localhost:4000
```

This will create a tunnel and you’ll see something like this in the terminal:

<Frame>
  <img />
</Frame>

Remember, the exact URL (`/api/novu` or similar) you expose in your application for handling Novu Framework requests is what you'd consider the `Bridge URL`.

This URL would be the endpoint within your application's domain where Novu's Worker Engine sends requests to fetch notification content or subscriber details dynamically. In our case, it is this: [https://faec-2409-40f2-3c-3b57-400e-a7f7-1fc0-1e5.ngrok-free.app/api/echo](https://faec-2409-40f2-3c-3b57-400e-a7f7-1fc0-1e5.ngrok-free.app/api/echo)
So, we’ll enter this Bridge URL:

<Frame>
  <img />
</Frame>

And create diff:

<Frame>
  <img />
</Frame>

## Testing our workflow

Once you’ve synced your changes in the previous step, you’ll see a notification that says ‘Sync complete’ and you can now go to Novu Cloud using the ‘Test your workflows’ link and trigger a notification.

<Frame>
  <img />
</Frame>

You’ll see the workflow you’ve created has a blue lightning bolt icon. That icon signifies that the corresponding workflow has been created with Novu Framework:

<Frame>
  <img />
</Frame>

Simply open the workflow and you can send a test email from there.

<Note>
  Make sure that all the expected payload variables and step inputs are being sent in their respective fields!
</Note>

<Frame>
  <img />
</Frame>

This is the workflow test email in my inbox:

<Frame>
  <img />
</Frame>

Once tested, you can simply have this workflow triggered whenever you want. For instance, a typical use case is to have a workflow triggered when an event occurs. To replicate it, I’ve attached a handler function that triggers this workflow when the `submit` event fires:

Here’s a simple replication of the stipulated scenario:

```jsx theme={null}
'use client';

import { useState } from 'react';

export default function Home() {
  const [loading, setLoading] = useState(false);
  const [text, setText] = useState('')
  const [email, setEmail] = useState('')


  const triggerWorkflow = async () => {
    setLoading(true);
    const response = await fetch('/api/users', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        text: text,
        email: email
      }),
    });
    const result = await response.json();
    setLoading(false);
    console.log(result);
  };
  return (
    <div>
      <h1>MJML Email with Novu Framework</h1>
      <input placeholder='Enter customer name' onChange={e => setText(e.target.value)} value={text} />
      <input placeholder='Enter customer email' onChange={e => setEmail(e.target.value)} value={email} />
      <button onClick={triggerWorkflow} disabled={loading}>
        {loading ? 'Sending...' : 'Send Email'}
      </button>
    </div>
  );
}

```

And the corresponding route it hits:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<Your Novu API Key>');

export async function POST(request: Request) {
  const res = await request.json();

  await novu.trigger('mjml-email-workflow', {
    to: {
      subscriberId: 'novu-sub-two',
      email: res.email
    },
    payload: {
      text: res.text,
    },
  });

  console.log('triggered')
  return Response.json({ success: true });
}
```

So there you go!

This is how you create workflows using Novu Framework and deploy your changes seamlessly to the Novu cloud. You can check out the code for a [sample demo app](https://github.com/novuhq/framework-mjml).

Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows.

Don’t forget to share your workflows with us and as always, hit us up on Discord with any questions you might have!


# How to send notifications with Nuxt.js and Vuemail
Source: https://v0.x-docs.novu.co/guides/framework-guides/framework-nuxt-vuemail

Learn how to send email notifications with Nuxt.js, Vuemail and Novu

This guide assumes you know what [a notification workflow](https://docs.novu.co/workflows/notification-workflows) is and why you need it. It also assumes you are aware of [Nuxt](https://nuxt.com/) and [VueEmail](https://vuemail.net/).
Fantastic. Now that we are all on the same page let’s proceed.

Novu recently released a new way of baking notification workflows into your apps via code, and it’s huge! Let me walk you through it.

It’s called Novu Framework and you can learn more about it by visiting the related [documentation](https://docs.novu.co/framework/quickstart). You might also benefit from reading this excellent [Code-First Approach to Managing Notification Workflows](https://novu.co/blog/a-code-first-approach-to-managing-notification-workflows/) article.

If you prefer to clone the repository from GitHub and get your hands dirty, we aren’t going to stop you. You can find it [here](https://github.com/novuhq/novu-framework-nuxt-vue-email-example).

Still here? Good, I wrote this guide for you!

## Getting Started

## 1. Initialize **New Nuxt Project**

We will follow the [official installation guide from Nuxt](https://nuxt.com/docs/getting-started/installation), open your terminal / IDE, and run the following command:

```jsx theme={null}
npx nuxi@latest init <project-name>
```

## 2. **Integrate Novu Framework Into Our App (Notification Workflow)**

1. We will install the `@novu/framework` package in the root of our Nuxt app directory by running the following command:

```jsx theme={null}
npm install @novu/framework
```

2. We must provide an API endpoint for the [Novu Dev Studio](https://docs.novu.co/framework/concepts/studio) to fetch our notification workflow. (Don’t worry; we guide you through all the steps.) Navigate to your app's `app/server` directory and create a new directory named `api`.

```jsx theme={null}
cd app/server

mkdir api
```

Create a file within the `app/server/api` directory and name it `novu.ts`.  Copy and paste the code snippet below:

```jsx theme={null}
// app/server/api/novu.ts
import { serve } from "@novu/framework/nuxt";
import { client, myWorkflow } from "../novu/workflows";

export default defineEventHandler(serve({ client: client, workflows: [myWorkflow] }));
```

3. Now, let's create the instance where we will build and maintain our notification workflow:

Navigate to your `app/server` directory and create another directory named `novu`.

```jsx theme={null}
cd app/server

mkdir novu
```

Create a file within the `app/server/novu` directory and name it `workflows.ts`.  Copy and paste the code snippet below:

```jsx theme={null}
// app/server/novu/workflows.ts
// This workflow already renders vue email template.

import { config } from '@vue-email/compiler'
import { Client, workflow } from '@novu/framework';

const vueEmail = config('templates', {
  verbose: false,
  options: {
  },
})

export const client = new Client({
  /**
   * Disable this flag only during local development
   * For production this should be true
   */
  strictAuthentication: process.env.NODE_ENV !== "development"
});

export const myWorkflow = workflow('hello-world', async ({ step, payload }) => {
    await step.email(
        'send-email',
        async () => {
            const template = await vueEmail.render('sample-email.vue', {
                props: payload,
            });
            return {
                subject: `You have a new invitation from: ${payload.username}.`,
                body: template.html,
            }
        });
},
    {
        payloadSchema: {
            // Always `object`
            type: 'object',
            // Specify the properties to validate. Supports deep nesting.
            properties: {
                        username: { type: "string" },
                        invitedByEmail: { type: "string" },
                        inviteLink: { type: "string" },
                        inviteFromIp: { type: "string" },
                        inviteFromLocation: { type: "string" }
            },
            // Used to enforce full type strictness, with no rogue properties.
            additionalProperties: false,
            // The `as const` is important to let Typescript know that this
            // type won't change, enabling strong typing on `inputs` via type
            // inference of the provided JSON Schema.
        } as const,
    },
);
```

We haven’t finished the guide yet but have everything to build a notification workflow.

Below, We can see a “plain” Client instance and shaping your desired workflow.

```jsx theme={null}
// app/server/novu/workflows.ts
// This is Client instance concept - not a working instance!

import { Client, workflow } from '@novu/framework';

export const client = new Client({
  /**
   * Disable this flag only during local development
   * For production this should be true
   */
  strictAuthentication: process.env.NODE_ENV !== "development"
});

export const myWorkflow = workflow(
	'<WORKFLOW_NAME>', // The Workflow name. Must be unique across your Bridge application.
	// Workflow resolver, the entry-point for your Workflow steps
	async ({
		// Helper function to declare your Workflow Steps.
		step,
		// Workflow Trigger payload
		payload,
	}) => {
	// ...your Workflow Steps
}, {
	// JSON Schema for validation and type-safety. Zod, and others coming soon.
	// https://json-schema.org/draft-07/json-schema-release-notes

	// The schema for the Workflow payload passed dynamically via Novu Trigger API
	// Defaults to an empty schema.
	payloadSchema: { properties: { name: { type: 'string' }}},
	// The schema for the Workflow inputs passed statically via Novu Web
	// Defaults to an empty schema.
	inputSchema: { properties: { brandColor: { type: 'string' }}},
});
```

We can:

* Select a name for our workflow.
* Declare [Workflow Steps](https://docs.novu.co/framework/steps/introduction) as we see fit for our use case
* Configure what could be passed in the payload of the Workflow Trigger ([payloadSchema](https://docs.novu.co/framework/concepts/inputs))
* Configure what inputs could be passed statically via Novu Web ([inputSchema](https://docs.novu.co/framework/concepts/inputs))

Note: You can create and manage as many workflows as you wish within `app/server/novu/workflows.ts`; make sure to provide each workflow with a unique name.

## 3. Adding Vuemail in our notification workflow

1. We will install the `vue-email` package in the root of our Nuxt app directory by running the following command:

```jsx theme={null}
npm install vue-email
```

2. We will create one more directory in the root of our directory and name it `templates`. That is where our vue-email templates will be stored.

```c theme={null}
mkdir templates
```

3. In the `app/templates` directory, we will create a file for our first vue-email template and name it `sample-email.vue`.

[You can find examples of Vue email templates here.](https://vuemail.net/playground)

```jsx theme={null}
// app/templates/sample-email.vue

<script setup lang="ts">
import { defineProps, withDefaults } from 'vue'

interface Props {
  invitedByUsername?: string
  teamName?: string
  username?: string
  invitedByEmail?: string
  inviteLink?: string
  inviteFromIp?: string
  inviteFromLocation?: string
  showFootnote?: boolean;
  components: string[] | null
}

const baseUrl = "https://react-email-demo-bdj5iju9r-resend.vercel.app";

const props = withDefaults(defineProps<Props>(), {
  teamName: 'Cleaning',
  username: 'John Doe',
  invitedByEmail: 'anpch@example.com',
  inviteLink: 'https://acme.com/projects/accept/foo',
  inviteFromIp: '172.0.0.1',
  inviteFromLocation: 'San Francisco, CA',
  showFootnote: true,
  components: null
})

const previewText = `Join ${props.invitedByUsername} on Vercel`
</script>

<template>
  <ETailwind>
    <EHtml>
      <EHead />
      <EPreview>{{ previewText }}</EPreview>
      <EBody class="bg-white my-auto mx-auto font-sans">
        <EContainer class="border border-solid border-[#eaeaea] p-[20px] md:p-7 rounded my-[40px] mx-auto max-w-[465px]">
          <div v-for="item in components || []">
            <EButton v-if="item === 'button'" px="20" py="12" class="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center" :href="inviteLink"> Accept </EButton>
            <EText v-if="item === 'text'" class="text-black text-[14px] leading-[24px]"> Hello {{ username }}, </EText>
            <EHr v-if="item === 'divider'" class="border border-solid border-[#eaeaea] my-[26px] mx-0 w-full" />
          </div>
          <ESection class="mt-[32px]">
            <EImg :src="`${baseUrl}/static/vercel-logo.png`" width="40" height="37" alt="Vercel" class="my-0 mx-auto" />
          </ESection>
          <Hello />
          <EHeading class="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
            New Project <strong>{{ teamName }}</strong> available
          </EHeading>
          <EText class="text-black text-[14px] leading-[24px]"> Hello {{ username }}, </EText>
          <EText class="text-black text-[14px] leading-[24px]">
            <strong>{{invitedByUsername}}</strong> (
            <ELink :href="`mailto:${invitedByEmail}`" class="text-blue-600 no-underline">
              {{ invitedByEmail }}
            </ELink>
            ) has invited you to the <strong>{{ teamName }}</strong> project on <strong>Acme</strong>.
          </EText>
          <ESection>
            <ERow>
              <EColumn align="right">
                <EImg class="rounded-full" :src="`${baseUrl}/static/vercel-user.png`" width="64" height="64" />
              </EColumn>
              <EColumn align="center">
                <EImg :src="`${baseUrl}/static/vercel-arrow.png`" width="12" height="9" alt="invited you to" />
              </EColumn>
              <EColumn align="left">
                <EImg class="rounded-full" :src="`${baseUrl}/static/vercel-team.png`" width="64" height="64" />
              </EColumn>
            </ERow>
          </ESection>
          <ESection class="text-center mt-[32px] mb-[32px]">
            <EButton px="20" py="12" class="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center" :href="inviteLink"> Accept </EButton>
            <EButton px="20" py="12" class="rounded text-[12px] font-semibold no-underline text-center" :href="inviteLink"> Decline </EButton>

          </ESection>
          <EText class="text-black text-[14px] leading-[24px]">
            or copy and paste this URL into your browser:
            <ELink :href="inviteLink" class="text-blue-600 no-underline">
              {{ inviteLink }}
            </ELink>
          </EText>

          <EHr class="border border-solid border-[#eaeaea] my-[26px] mx-0 w-full" />
          <EText v-if="showFootnote" class="text-[#666666] text-[12px] leading-[24px]">
            This invitation was intended for
            <span class="text-black">{{ username }} </span>.This invite was sent from <span class="text-black">{{ inviteFromIp }}</span> located in
            <span class="text-black">{{ inviteFromLocation }}</span
            >. If you were not expecting this invitation, you can ignore this email. If you are concerned about your account's safety, please reply to this email to get in touch
            with us.
          </EText>

        </EContainer>
      </EBody>
    </EHtml>
  </ETailwind>
</template>
```

## 4. Launching The Dev Studio

Now that we have everything in our notification workflow configured along with the vue-email template we will use, it’s time to see a visual representation of what we have built.

1. If you haven’t run the development environment for your Nuxt app, now is the time.

   ```jsx theme={null}
   npm run dev
   ```

2. Do you remember that we exposed an Bridge API endpoint in our app for Dev Studio to catch? This is where it happens.

   Run the following command in a separate terminal:

   ```jsx theme={null}
   npx novu-labs@latest echo
   ```

   If you’ve followed this guide, you should see this:

   <Frame>
     <img />
   </Frame>

   Here is where our exact API endpoint goes. If our application runs on a different port, we should change the URL manually to point Dev Studio in the right direction.

   <Frame>
     <img />
   </Frame>

   Also, if we have configured everything correctly, we should see that Dev Studio sees our workflow identifier (Workflow unique name).

   <Frame>
     <img />
   </Frame>

3. Click the “View Workflow” button in the Dev Studio to see the workflow.

   We should see the following:

   <Frame>
     <img />
   </Frame>

Click on the workflow step node called `send-email`. We should see a preview of our email template and the `Step Input` and `Payload` variables we have configured in the workflow schemas.

<Frame>
  <img />
</Frame>

4. This is the time to adjust the email template, step input schema, or define the properties we anticipate in the payload. We have a live representation of everything. You can add more steps like In-App, SMS, and chat.

## 5. Syncing our workflow to Novu Cloud

Having completed crafting, designing, and modifying our notification workflow to suit our requirements, we're ready to push it to Novu Cloud. There, it will handle the heavy lifting and seamlessly execute all the steps we've configured whenever we trigger the workflow.

1. Click on the `Sync to Cloud` button on the top right.

   <Frame>
     <img />
   </Frame>

2. We will need to create a local tunnel that the Novu Cloud environment can reach for local experimentation purposes.

   <Frame>
     <img />
   </Frame>

   On a separate terminal, run the following command:

   ```jsx theme={null}
   // Change to the port where the app is currently running

   npx localtunnel --port 3000
   ```

   We should get something like:

   ```jsx theme={null}
   your url is: https://famous-pumas-clap.loca.lt
   ```

   <Frame>
     <img />
   </Frame>

3. Click the `Create Diff` button. To push (merge) the workflow code to the cloud, an API Key from our Novu account should be added to our Framework Client instance.

   <Frame>
     <img />
   </Frame>

   Let’s navigate to `../app/server/novu/workflows.ts` file and add our Novu API Key.

```jsx theme={null}
// app/server/novu/workflows.ts
// This workflow already renders vue email template.

import { config } from '@vue-email/compiler'
import { Client, workflow } from '@novu/framework';

const vueEmail = config('templates', {
  verbose: false,
  options: {
  },
})

export const client = new Client({
  apiKey: process.env.NOVU_API_KEY, // <<-- Your Novu API KEY
  /**
   * Disable this flag only during local development
   * For production this should be true
   */
  strictAuthentication: process.env.NODE_ENV !== "development"
});

export const myWorkflow = workflow('hello-world', async ({ step, payload }) => {
    await step.email(
        'send-email',
        async () => {
            const template = await vueEmail.render('sample-email.vue', {
                props: payload,
            });
            return {
                subject: `You have a new invitation from: ${payload.username}.`,
                body: template.html,
            }
        });
},
    {
        payloadSchema: {
            // Always `object`
            type: 'object',
            // Specify the properties to validate. Supports deep nesting.
            properties: {
                        username: { type: "string" },
                        invitedByEmail: { type: "string" },
                        inviteLink: { type: "string" },
                        inviteFromIp: { type: "string" },
                        inviteFromLocation: { type: "string" }
            },
            // Used to enforce full type strictness, with no rogue properties.
            additionalProperties: false,
            // The `as const` is important to let Typescript know that this
            // type won't change, enabling strong typing on `inputs` via type
            // inference of the provided JSON Schema.
        } as const,
    },
);
```

We will now click the `Create Diff` button again.

<Frame>
  <img />
</Frame>

This is where you can review all the changes made to the workflow. Once you have verified that everything is in order, go ahead and click the `Deploy Changes` button.

<Frame>
  <img />
</Frame>

## 6. Testing Our Notification Workflow

There are many ways to test and [trigger our workflow](https://docs.novu.co/api-reference/events/trigger-event), but we'll make a `cURL` API call to Novu Cloud from our terminal in this guide.

If we don't have any subscribers or users in our database or within our Novu Cloud organization, we'll send the test to ourselves for simplicity.

* In the `subscriberId` key, input a random number or even our email address (as long as we do not try to assign the same ID key to another subscriber, we should be good).
* For the `email` key, we will need to insert a valid email address so we can actually receive the email.

<Info>**Note:** Learn more about the structure of [subscriber properties](https://docs.novu.co/subscribers/subscribers).</Info>

We can leave the payload empty or add properties aligned with the `payloadSchema` we established in the workflow definition.

```jsx theme={null}

curl -X POST https://api.novu.co/v1/events/trigger \
  -H "Authorization: ApiKey <NOVU_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "hello-world",
    "to": {
      "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      "email": "john@doemail.com",
    },
    "payload": {
        "username": "Jane Doe",
		    "invitedByEmail": "Jane@doemail.com",
		    "inviteLink": "https://acme.com/projects/accept/foo",
		    "inviteFromIp": "172.0.0.1",
		    "inviteFromLocation": "New York, DC"
    }
  }'

```

Now, let’s check our email inbox.

* No longer limited by UI notification steps and rigidity.
* No longer limited by notification content editors and systems. The more, the merrier!
* Now an IFTTT (If-This-Then-That) pro engineer!

Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows. Have fun, and share your use case on Discord with us!


# How to send notifications with Next.js and React email
Source: https://v0.x-docs.novu.co/guides/framework-guides/framework-react-email

Leverage the React email package to send email notifications

# Introduction

In this guide, you’ll learn how to send email notifications using the React email package. But before we jump into it, let's first take a look at the prerequisites!

## Pre-requisites

* A Novu account
* Node installed on your machine
* A working NextJS development environment

## Get started with Novu Framework

[Novu Framework](https://docs.novu.co/framework/quickstart) is a "notifications as code" approach that enables developers to define workflows as functions and integrate them with their preferred libraries for email, SMS, and chat generation.

1. To get started with Novu Framework, just run this command in your terminal, it’ll scaffold a new NextJS project with Novu Framework and we’ll be ready to roll!

```jsx theme={null}
npx create-novu-app --api-key=<YOUR_API_KEY>
```

2. Once you execute this command, you’ll be asked to give your project a name. I’ll keep the default `my-novu-app` but you can choose your own.

<Frame>
  <img />
</Frame>

3. You’ll then be asked if you want to use React-email or not. You can choose to install it at this step itself or proceed with No and then install it later. I’m choosing the default No option.

<Frame>
  <img />
</Frame>

4. After this step, all the dependencies will be installed and you will be able to start using Novu Framework.

<Frame>
  <img />
</Frame>

5. Once this installation is complete, simply cd into the directory and start your app using the `npm run dev` command, and your app will be served on `localhost:4000`

<Note>
  Make sure that the port 4000 isn’t already being used!
</Note>

You’ll now have a NextJS app running on `http://localhost:4000` and you can make changes to your app as you see fit. Let’s now move to the meaty stuff - using Novu Framework in a NextJS app and the magic of Dev Studio.

## Echo Dev Studio

The Echo Dev Studio is a companion app to the Echo Client SDK. Its goal is to provide a local environment that lives near your code.

To launch the dev studio locally you can run: `npx novu-labs@latest echo`. The Dev Studio will be started by default on port `2022`, and accessible via: `http://localhost:2022`

<Frame>
  <img />
</Frame>

Here’s how the Dev Studio looks on the first run:

<Frame>
  <img />
</Frame>

You’ll notice that it asks for an `Bridge endpoint` at the bottom. Novu Framework requires a single HTTP endpoint (`/api/novu` or similar) to be exposed by your application. This endpoint is used to receive events from our Worker Engine. We have more on Bridge endpoint [in our docs.](https://docs.novu.co/framework/concepts/endpoint)

<Note>
  You can view the Bridge Endpoint as a webhook endpoint that Novu will call when it needs to retrieve contextual information for a given subscriber and notification.
</Note>

Just enter the full URL of your Bridge Endpoint. In our case, it is `http://localhost:4000/api/echo`

<Frame>
  <img />
</Frame>

Once you do, you’ll see a green checkmark alongside the URL input box and a green `connected` highlight at the top right corner.

## Installing and configuring React Email

<Note>
  If you opted for installing React Email in our CLI set-up process, you can skip installing it again.
</Note>

Integrating React Email with Novu in our NextJS app is quite straightforward. Following are the steps to get it installed and configured:

1. Simply run the following command to install it like any other npm package:

```jsx theme={null}
  npm i @react-email/components react-email
```

Once installed, proceed to write an email template in the next step

2. To write an email template, you can look over some of the examples in the [React Email documentation](https://react.email/examples) to get inspiration. In our case, this is the template:

```jsx theme={null}
import {
  Body,
  Button,
  Container,
  Column,
  Head,
  Hr,
  Html,
  Img,
  Link,
  render,
  Row,
  Section,
  Text,
  Tailwind,
} from "@react-email/components";
import * as React from "react";

interface VercelInviteUserEmailProps {
  username?: string;
  userImage?: string;
  invitedByUsername?: string;
  invitedByEmail?: string;
  teamName?: string;
  teamImage?: string;
  inviteLink?: string;
  inviteFromIp?: string;
  showJoinButton?: boolean;
  inviteFromLocation?: string;
  buttonText?: string
}

const baseUrl = process.env.VERCEL_URL
  ? `https://${process.env.VERCEL_URL}`
  : "";

export const VercelInviteUserEmail = ({
  username,
  userImage,
  invitedByUsername,
  invitedByEmail,
  teamName,
  teamImage,
  inviteLink,
  inviteFromIp,
  inviteFromLocation,
  showJoinButton,
  buttonText
}: VercelInviteUserEmailProps) => {

  return (
    <Html>
      <Head />
      <Tailwind>
        <Body className="bg-white my-auto mx-auto font-sans px-2">
          <Container className="border border-solid border-[#eaeaea] rounded my-[40px] mx-auto p-[20px] max-w-[465px]">
            <Section className="mt-[32px]">
              <Img
                src={`https://react-email-demo-ndjnn09xj-resend.vercel.app/static/vercel-logo.png`}
                width="40"
                height="37"
                alt="Vercel"
                className="my-0 mx-auto"
              />
            </Section>
            <Text className="text-black text-[14px] leading-[24px]">
              Hello {username},
            </Text>
            <Text className="text-black text-[14px] leading-[24px]">
              <strong>{invitedByUsername}</strong> (
              <Link
                href={`mailto:${invitedByEmail}`}
                className="text-blue-600 no-underline"
              >
                {invitedByEmail}
              </Link>
              ) has invited you to the <strong>{teamName}</strong> team on{" "}
              <strong>Vercel</strong>.
            </Text>
            <Section>
              <Row>
                <Column align="right">
                  <Img
                    className="rounded-full"
                    src={userImage}
                    width="64"
                    height="64"
                  />
                </Column>
                <Column align="center">
                  <Img
                    src={`https://react-email-demo-ndjnn09xj-resend.vercel.app/static/vercel-arrow.png`}
                    width="12"
                    height="9"
                    alt="invited you to"
                  />
                </Column>
                <Column align="left">
                  <Img
                    className="rounded-full"
                    src={teamImage}
                    width="64"
                    height="64"
                  />
                </Column>
              </Row>
            </Section>
            {showJoinButton && (
              <Section className="text-center mt-[32px] mb-[32px]">
                <Button
                  className="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center px-5 py-3"
                  href={inviteLink}
                >
                  {buttonText}
                </Button>
              </Section>
            )}
            <Text className="text-black text-[14px] leading-[24px]">
              or copy and paste this URL into your browser:{" "}
              <Link href={inviteLink} className="text-blue-600 no-underline">
                {inviteLink}
              </Link>
            </Text>
            <Hr className="border border-solid border-[#eaeaea] my-[26px] mx-0 w-full" />
            <Text className="text-[#666666] text-[12px] leading-[24px]">
              This invitation was intended for{" "}
              <span className="text-black">{username}</span>. This invite was
              sent from <span className="text-black">{inviteFromIp}</span>{" "}
              located in{" "}
              <span className="text-black">{inviteFromLocation}</span>. If you
              were not expecting this invitation, you can ignore this email. If
              you are concerned about your account's safety, please reply to
              this email to get in touch with us.
            </Text>
          </Container>
        </Body>
      </Tailwind>
    </Html>
  );
};

VercelInviteUserEmail.PreviewProps = {
  username: "alanturing",
  userImage: `${baseUrl}/static/vercel-user.png`,
  invitedByUsername: "Alan",
  invitedByEmail: "alan.turing@example.com",
  teamName: "Enigma",
  teamImage: `${baseUrl}/static/vercel-team.png`,
  inviteLink: "https://vercel.com/teams/invite/foo",
  inviteFromIp: "204.13.186.218",
  inviteFromLocation: "São Paulo, Brazil",
} as VercelInviteUserEmailProps;

export default VercelInviteUserEmail;

export function renderReactEmail(input: any, payload: any) {
  return render(<VercelInviteUserEmail {...input}{...payload} />);

}
```

3. And as final step, we need to define the workflow that uses the template defined above.

```jsx theme={null}
export const newSignup = workflow('new-signup', async ({ step, payload }) => {
  // Send a welcome email
  await step.email('send-email', async (inputs) => {
    return {
      subject: `Welcome to Novu, ${payload.username}`,
      body: renderReactEmail(inputs, payload),
    };
  }, {
    inputSchema: {
      type: "object",
      properties: {
        showJoinButton: { type: "boolean", default: true },
        buttonText: { type: "string", default: "Join the team" },
        userImage: {
          type: "string",
          default: "https://react-email-demo-bdj5iju9r-resend.vercel.app/static/vercel-user.png",
          format: "uri",
        },
        invitedByUsername: { type: "string", default: "Alan" },
        invitedByEmail: {
          type: "string",
          default: "alan.turing@example.com",
          format: "email",
        },
        teamName: { type: "string", default: "Team Awesome" },
        teamImage: {
          type: "string",
          default: "https://react-email-demo-bdj5iju9r-resend.vercel.app/static/vercel-team.png",
          format: "uri",
        },
        inviteLink: {
          type: "string",
          default: "https://vercel.com/teams/invite/foo",
          format: "uri",
        },
        inviteFromIp: { type: "string", default: "204.13.186.218" },
        inviteFromLocation: {
          type: "string",
          default: "São Paulo, Brazil",
        },
      },
    },
  });
  // JSON Schema for validation and type-safety. Zod, and others coming soon.
}, { payloadSchema: { properties: { text: { type: 'string' } } } });
```

Once you do this, you’ll see this workflow, the steps in the workflow, step inputs, payload variables and, the rendered view of this workflow on the Echo Dev Studio:

<Frame>
  <img />
</Frame>

Here, from the Dev Studio, you or your peers can change things like the text of a button, toggle visibility of a button, static text content, etc, and have it synced with the cloud with the `Sync to Cloud` button.

### Payload vs Step Inputs

Notice that in the Echo dev studio above, we’ve used payload as well as step inputs. Here’s how you can decide if you need either or both:

* Payload is used for dynamic content that changes from one notification to another based on events occurring in your system.
* Step Inputs are for static elements or predefined options that non-technical team members can modify without altering the codebase.
* Payload is controlled by developers and passed dynamically through the novu.trigger method.
* Step Inputs are defined by developers but are meant to be utilized and modified by non-technical peers.
* Payload examples include User ID, Post ID, Comment, Order ID, 2FA token, etc., which are likely to change with each notification.
* Step Inputs examples include the text of a button, whether a section should be shown, static text content, etc., which are generally static but configurable elements.
* Payload modifications are made in the code by developers at the time of triggering a notification.
* Step Inputs can be modified directly in the UI, offering a no-code solution for non-technical team members to make changes.
* Payload data is passed during the novu.trigger method and is part of the dynamic data handling process within notification workflows.
* Step Inputs are predefined in the workflow configuration and can be adjusted through the Echo Dev Studio, affecting how notifications are rendered without changing the workflow logic.

## Syncing with the cloud, with the click of a button

Once done with the workflow, now we need to sync it to the cloud. Fortunately, Novu Framework makes it a breeze to sync changes from the local machine to the cloud and it all happens with a click of a button.

To enable our cloud environment to talk to your local Echo instance, you need to supply an Echo endpoint URL. This sets up a communication channel between our cloud environment and your local instance. To allow Novu to communicate with your local machine a tunnel will need to be generated.

The `create-novu-app` command sets up `localtunnel` for you. Running the `npm run dev` script in the project launches both the Bridge application and the tunnel solution. The tunnel URL shows up in the console output.

You can also use a tool like `ngrok`:

```bash theme={null}
// using ngrok 
ngrok http http://localhost:<YOUR_EDGE_PORT>      
```

In our case, the app is running on port 4000 so we’ll use:

```bash theme={null}
ngrok http http://localhost:4000
```

This will create a tunnel and you’ll see something like this in the terminal:

<Frame>
  <img />
</Frame>

Remember, the exact URL (`/api/novu` or similar) you expose in your application for handling Novu Framework requests is what you'd consider the `Bridge URL`.

This URL would be the endpoint within your application's domain where Novu's Worker Engine sends requests to fetch notification content or subscriber details dynamically. In our case, it is this: `https://0536-2409-40f2-1039-43e1-3053-d98e-c276-ee5.ngrok-free.app/api/echo`

So, we’ll enter this Bridge URL:

<Frame>
  <img />
</Frame>

And create diff:

<Frame>
  <img />
</Frame>

## Testing our workflow

Once you’ve synced your changes in the previous step, you’ll see a notification that says ‘Sync complete’ and you can now go to Novu Cloud using the ‘Test your workflows’ link and trigger a notification.

<Frame>
  <img />
</Frame>

You’ll see the workflow you’ve created has a blue lightning bolt icon. That icon signifies that the corresponding workflow has been created with Novu Framework:

<Frame>
  <img />
</Frame>

Simply open the workflow and you can send a test email from there.

<Note>
  Make sure that all the expected payload variables and step inputs are being sent in their respective fields!
</Note>

<Frame>
  <img />
</Frame>

This is the workflow test email in my inbox:

<Frame>
  <img />
</Frame>

Once tested, you can simply have this workflow triggered whenever you want. For instance, a typical use case is to have a workflow triggered when an event occurs. To replicate it, I’ve attached a handler function that triggers this workflow when the `submit` event fires:

Here’s a simple replication of the stipulated scenario:

```jsx theme={null}
"use client"
import Image from "next/image";
import styles from "./page.module.css";
import React, { useState } from "react";
import axios from "axios";

export default function Home() {

  const [email, setEmail] = useState('')
  const [username, setUsername] = useState('')

  const onClickHandler = async (e: React.FormEvent<HTMLFormElement>) => {
    try {
      e.preventDefault();
      await fetch("/api/users", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          email: email,
          username: username,
        }),
      });

      // console.log('working fine');
    } catch (error) {
      console.error('Error:', error);
    }
  };
  return (
    <main style={{ height: '100vh', display: 'flex', justifyContent: 'center', alignItems: 'center' }}>
      <form onSubmit={(e) => onClickHandler(e)}>
        <input
          placeholder="Enter email id"
          onChange={(e) => setEmail(e.target.value)}
          style={{
            // Add your CSS-in-JS styles here
            padding: '0.5rem',
            marginBottom: '1rem',
            borderRadius: '0.25rem',
            border: '1px solid #ccc',
            width: '100%',
            boxSizing: 'border-box',
          }}
        />
        <input
          placeholder="Enter the name of invitee"
          onChange={(e) => setUsername(e.target.value)}
          style={{
            // Add your CSS-in-JS styles here
            padding: '0.5rem',
            marginBottom: '1rem',
            borderRadius: '0.25rem',
            border: '1px solid #ccc',
            width: '100%',
            boxSizing: 'border-box',
          }}
        />
        <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'center' }}>

          <button
            style={{
              // Add your CSS-in-JS styles here
              padding: '0.5rem 1rem',
              backgroundColor: '#4CAF50',
              color: 'white',
              border: 'none',
              borderRadius: '0.25rem',
              cursor: 'pointer',
            }}
          >
            Submit
          </button>
        </div>
      </form>
    </main>
  );
}
```

And the corresponding route it hits:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<Your Novu API Key>');

export async function POST(request: Request) {
  const res = await request.json();

  await novu.trigger('<Workflow name>', {
    to: {
      subscriberId: '<subscriber ID>',
    },
    payload: {
      email: res.email,
      username: res.username,
    },
  });

  console.log('triggered')
  return Response.json({ success: true });
}
```

## More workflow examples

Creating workflows with Novu Framework is a breeze. Here are a couple of other examples from React email docs created with Novu Framework:

1. AWS Email verification example

<Frame>
  <img />
</Frame>

2. Apple invoice email example

<Frame>
  <img />
</Frame>

## Conclusion

So there you go!

This is how you create workflows using Novu Framework and deploy your changes seamlessly to the Novu cloud. You can check out the code for a [sample demo app](https://github.com/novuhq/novu-framework-nextjs-react-email-example).
Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows.

<br />

Don’t forget to share your workflows with us and as always, hit us up on Discord with any questions you might have!


# How to send notifications with Remix and React email
Source: https://v0.x-docs.novu.co/guides/framework-guides/framework-remix

Learn how to send email notifications with Remix, React email and Novu

# Introduction

Learn how to send notifications with Remix, React email and Novu. You can check out the complete code for a [working app](https://github.com/novuhq/novu-framework-remix-example).

## Prerequisites

* A Novu account
* Node installed on your machine
* A working Remix app

## Follow these Steps

### 1. Install all dependencies including react email components

```jsx theme={null}
  npm install @novu/framework @react-email/components react-email
```

### 2. Integrate Novu with Remix

Within the `app/routes` directory, create an `api.novu.tsx` file.

```jsx theme={null}
// app/routes/api.novu.tsx

import { serve } from "@novu/framework/remix";
import { client, signUpWorkflow } from "~/novu/workflows";

const handler = serve({
    client: client,
    workflows: [signUpWorkflow]
  });
  
export { handler as action, handler as loader };
```

### 3. Create an email template in your Remix app

Within the `app` directory, create an `emails` folder and add an email template file to it.

In this scenario, create a `vercel-invite-user.tsx` file and the code below to it:

```ts theme={null}
// app/emails/vercel-invite-user.tsx

import {
    Body,
    Button,
    Container,
    Column,
    Head,
    Heading,
    Hr,
    Html,
    Img,
    Link,
    render,
    Row,
    Section,
    Text,
    Tailwind,
  } from "@react-email/components";
  
  interface VercelInviteUserEmailProps {
    username?: string;
    userImage?: string;
    invitedByUsername?: string;
    invitedByEmail?: string;
    teamName?: string;
    teamImage?: string;
    inviteLink?: string;
    inviteFromIp?: string;
    showJoinButton?: boolean;
    inviteFromLocation?: string;
    buttonText?: string
  }
  
  const baseUrl = process.env.VERCEL_URL
    ? `https://${process.env.VERCEL_URL}`
    : "";
  
  export const VercelInviteUserEmail = ({
    username,
    userImage,
    invitedByUsername,
    invitedByEmail,
    teamName,
    teamImage,
    inviteLink,
    inviteFromIp,
    inviteFromLocation,
    showJoinButton,
    buttonText
  }: VercelInviteUserEmailProps) => {
  
    return (
      <Html>
        <Head />
        <Tailwind>
          <Body className="bg-white my-auto mx-auto font-sans px-2">
            <Container className="border border-solid border-[#eaeaea] rounded my-[40px] mx-auto p-[20px] max-w-[465px]">
              <Section className="mt-[32px]">
                <Img
                  src={`https://react-email-demo-ndjnn09xj-resend.vercel.app/static/vercel-logo.png`}
                  width="40"
                  height="37"
                  alt="Vercel"
                  className="my-0 mx-auto"
                />
              </Section>
              <Heading className="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
                Join <strong>{teamName}</strong> on <strong>Vercel</strong>
              </Heading>
              <Text className="text-black text-[14px] leading-[24px]">
                Hello {username},
              </Text>
              <Text className="text-black text-[14px] leading-[24px]">
                <strong>{invitedByUsername}</strong> (
                <Link
                  href={`mailto:${invitedByEmail}`}
                  className="text-blue-600 no-underline"
                >
                  {invitedByEmail}
                </Link>
                ) has invited you to the <strong>{teamName}</strong> team on{" "}
                <strong>Vercel</strong>.
              </Text>
              <Section>
                <Row>
                  <Column align="right">
                    <Img
                      className="rounded-full"
                      src={userImage}
                      width="64"
                      height="64"
                    />
                  </Column>
                  <Column align="center">
                    <Img
                      src={`https://react-email-demo-ndjnn09xj-resend.vercel.app/static/vercel-arrow.png`}
                      width="12"
                      height="9"
                      alt="invited you to"
                    />
                  </Column>
                  <Column align="left">
                    <Img
                      className="rounded-full"
                      src={teamImage}
                      width="64"
                      height="64"
                    />
                  </Column>
                </Row>
              </Section>
              {showJoinButton && (
                <Section className="text-center mt-[32px] mb-[32px]">
                  <Button
                    className="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center px-5 py-3"
                    href={inviteLink}
                  >
                    {buttonText}
                  </Button>
                </Section>
              )}
              <Text className="text-black text-[14px] leading-[24px]">
                or copy and paste this URL into your browser:{" "}
                <Link href={inviteLink} className="text-blue-600 no-underline">
                  {inviteLink}
                </Link>
              </Text>
              <Hr className="border border-solid border-[#eaeaea] my-[26px] mx-0 w-full" />
              <Text className="text-[#666666] text-[12px] leading-[24px]">
                This invitation was intended for{" "}
                <span className="text-black">{username}</span>. This invite was
                sent from <span className="text-black">{inviteFromIp}</span>{" "}
                located in{" "}
                <span className="text-black">{inviteFromLocation}</span>. If you
                were not expecting this invitation, you can ignore this email. If
                you are concerned about your account's safety, please reply to
                this email to get in touch with us.
              </Text>
            </Container>
          </Body>
        </Tailwind>
      </Html>
    );
  };
  
  VercelInviteUserEmail.PreviewProps = {
    username: "alanturing",
    userImage: `${baseUrl}/static/vercel-user.png`,
    invitedByUsername: "Alan",
    invitedByEmail: "alan.turing@example.com",
    teamName: "Enigma",
    teamImage: `${baseUrl}/static/vercel-team.png`,
    inviteLink: "https://vercel.com/teams/invite/foo",
    inviteFromIp: "204.13.186.218",
    inviteFromLocation: "São Paulo, Brazil",
  } as VercelInviteUserEmailProps;
  
  export default VercelInviteUserEmail;
  
  export function renderEmail(input: any, payload: any) {
    return render(<VercelInviteUserEmail {...input}{...payload} />);
  }
```

### 4. Create a Novu Workflow

Next, create a Novu workflow with an email step. This code-first notification workflow approach makes it easy for product teams to modify notification content.

Within the `app` directory, create an `novu` folder and add a `workflows.ts` file to it. Copy/paste the code below to the recently created file.

```jsx theme={null}
// app/novu/workflows.ts

import { Client, workflow } from '@novu/framework';
import { renderEmail } from '~/emails/vercel-invite-user';

export const client = new Client({

  apiKey: process.env.NOVU_API_KEY,
  /**
   * Disable this flag only during local development
   * For production this should be true
   */
  strictAuthentication: process.env.NODE_ENV !== "development"
});

export const signUpWorkflow = workflow('new-signup', async ({ step, payload }) => {
  // Send a welcome email
  await step.email('send-email', async (inputs) => {
    return {
      subject: `Welcome to sending emails with Novu & Remix`,
      body: renderEmail(inputs, payload),
    };
  }, {
    inputSchema: {
      type: "object",
      properties: {
        showJoinButton: { type: "boolean", default: true },
        buttonText: { type: "string", default: "Join the team" },
        userImage: {
          type: "string",
          default: "https://react-email-demo-bdj5iju9r-resend.vercel.app/static/vercel-user.png",
          format: "uri",
        },
        invitedByUsername: { type: "string", default: "Alan" },
        invitedByEmail: {
          type: "string",
          default: "alan.turing@example.com",
          format: "email",
        },
        teamName: { type: "string", default: "Team Awesome" },
        teamImage: {
          type: "string",
          default: "https://react-email-demo-bdj5iju9r-resend.vercel.app/static/vercel-team.png",
          format: "uri",
        },
        inviteLink: {
          type: "string",
          default: "https://vercel.com/teams/invite/foo",
          format: "uri",
        },
        inviteFromIp: { type: "string", default: "204.13.186.218" },
        inviteFromLocation: {
          type: "string",
          default: "São Paulo, Brazil",
        },
      },
    },
  });
  // JSON Schema for validation and type-safety. Zod, and others coming soon.
}, { payloadSchema: { properties: { text: { type: 'string' } } } });
```

### 5. Preview Email Workflow & Sync to Novu Cloud

Open Novu Dev Studio to preview and make changes to the email workflow as needed via the command below:

```jsx theme={null}
npx novu-labs@latest echo
```

1. Run the Studio

<Frame>
  <img />
</Frame>

**Note:** Use the port on which your Remix app is running for the Bridge endpoint so that the Novu Dev Studio can connect to your API route as highlighted in the image above.

2. Check out the signup email workflow and test

<Frame>
  <img />
</Frame>

3. Deploy to Novu Cloud when you're done.

On the top right(as seen in the image above) of the Novu Dev Studio, you can sync to Novu Cloud when you're done working locally.

**Note:** You'll need to create a local tunnel that the Novu Cloud environment can reach for local experimentation purposes. Ngrok is a good tunnel.

### 6. Send a Notification

Trigger a notification using the recently deployed workflow either via your [Novu Cloud dashboard](https://web.novu.co) or [code](/quickstarts/react#trigger-a-notification).

```js theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<API_KEY>");

novu.trigger("new-signup", {
  to: {
    subscriberId: "789",
  }
});
```

Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows.


# How to send notifications with Svelte and Svelte email
Source: https://v0.x-docs.novu.co/guides/framework-guides/framework-svelte

Learn how to send email notifications with Svelte, Svelte email and Novu

# Introduction

Learn how to send notifications with Svelte, Svelte email and Novu. You can check out the complete code for a [working app](https://github.com/novuhq/novu-svelte-email).

## Prerequisites

* A Novu account
* Node installed on your machine
* A working SvelteKit app

## Follow these Steps

### 1. Install all dependencies

```jsx theme={null}
  npm install @novu/framework svelte-email
```

### 2. Integrate Novu with SvelteKit

Within the `src/routes` directory, create an `api/novu` folder and add a `+server.ts` file to it.

```jsx theme={null}
// src/routes/api/novu/+server.ts

import { svelteWorkflow, client } from '$lib/novu/workflows';
import { serve } from '@novu/framework/sveltekit';

export const { GET, POST, PUT } = serve({ client: client, workflows: [svelteWorkflow] });
```

### 3. Create an email template in Svelte

Within the `src/lib` directory, create an `emails` folder and add an email template in a `.svelte` file to it.

For example, `airbnb-review.svelte`:

```ts theme={null}
// src/lib/emails/airbnb-review.svelte

<script lang="ts">
	import {
		Button,
		Container,
		Head,
		Heading,
		Hr,
		Html,
		Img,
		Link,
		Preview,
		Section,
		Text
	} from 'svelte-email';

        const baseUrl = 'https://svelte-email-rjaapma15-konzeptfabrik.vercel.app';

	export let authorName = 'Alex';
	export let showFeedbackButton = true;
	export let showLogoImage = true;
	export let feedbackButtonText = 'Send My Feedback';
	export let authorImage = `${baseUrl}/airbnb-review-user.jpeg`;
	export let logoImage = `${baseUrl}/airbnb-logo.png`;
	export let reviewText = `“Zeno was a great guest! Easy communication, the apartment was left
	  in great condition, very polite, and respectful of all house rules.
	  He’s welcome back anytime and would easily recommend him to any
	  host!”`;
	export let bottomAddress = "Airbnb, Inc., 888 Brannan St, San Francisco, CA 94103";

	const previewText = `Read ${authorName}'s review`;

	const fontFamily =
		'-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen-Sans,Ubuntu,Cantarell,"Helvetica Neue",sans-serif';

	const main = {
		backgroundColor: '#ffffff'
	};

	const container = {
		margin: '0 auto',
		padding: '20px 0 48px',
		width: '580px'
	};

	const userImage = {
		margin: '0 auto',
		marginBottom: '16px',
		borderRadius: '50%'
	};

	const heading = {
		fontFamily,
		fontSize: '32px',
		lineHeight: '1.3',
		fontWeight: '700',
		color: '#484848'
	};

	const paragraph = {
		fontFamily,
		fontSize: '18px',
		lineHeight: '1.4',
		color: '#484848'
	};

	const review = {
		...paragraph,
		padding: '24px',
		backgroundColor: '#f2f3f3',
		borderRadius: '4px'
	};

	const button = {
		fontFamily,
		backgroundColor: '#ff5a5f',
		borderRadius: '3px',
		color: '#fff',
		fontSize: '18px',
		textDecoration: 'none',
		textAlign: 'center' as const,
		display: 'block',
		width: '100%'
	};

	const link = {
		...paragraph,
		color: '#ff5a5f',
		display: 'block'
	};

	const reportLink = {
		fontFamily,
		fontSize: '14px',
		color: '#9ca299',
		textDecoration: 'underline'
	};

	const hr = {
		borderColor: '#cccccc',
		margin: '20px 0'
	};

	const footer = {
		fontFamily,
		color: '#9ca299',
		fontSize: '14px',
		marginBottom: '10px'
	};

</script>

<Html>
	<Head />
	<Preview preview={previewText} />
	<Section style={main}>
		<Container style={container}>
            {#if showLogoImage}
			    <Img src={logoImage} width="96" height="30" alt="Airbnb" />
            {/if}
			<Section>
				<Img src={authorImage} width="96" height="96" alt={authorName} style={userImage} />
			</Section>
			<Heading style={heading}>Here's what {authorName} wrote</Heading>
			<Text style={review}>{reviewText}</Text>
			<Text style={paragraph}>
				Now that the review period is over, we’ve posted {authorName}’s review to your Airbnb
				profile.
			</Text>
			<Text style={paragraph}>
				While it’s too late to write a review of your own, you can send your feedback to {authorName}
				using your Airbnb message thread.
			</Text>
			<Section style={{ padding: '16px 0 20px' }}>
                {#if showFeedbackButton}
				    <Button pY={19} style={button} href="https://airbnb.com/" >{feedbackButtonText}</Button>
                {/if}
			</Section>
			<Hr style={hr} />
			<Text style={{ ...paragraph, fontWeight: '700' }}>Common questions</Text>
			<Text>
				<Link href="https://airbnb.com/help/article/13" style={link}>How do reviews work?</Link>
			</Text>
			<Text>
				<Link href="https://airbnb.com/help/article/1257" style={link}>
					How do star ratings work?
				</Link>
			</Text>
			<Text>
				<Link href="https://airbnb.com/help/article/995" style={link}>
					Can I leave a review after 14 days?
				</Link>
			</Text>
			<Hr style={hr} />
			<Text style={footer}>{bottomAddress}</Text>
			<Link href="https://airbnb.com" style={reportLink}>Report unsafe behavior</Link>
		</Container>
	</Section>
</Html>
```

### 4. Create a Novu Workflow

Next, create a Novu workflow with an email step. This code-first notification workflow approach makes it easy for product teams to modify notification content.

```jsx theme={null}
// src/lib/novu/workflows.ts

import { Client, workflow } from '@novu/framework';
import { render } from 'svelte-email';
import AirbnbReview from '$lib/emails/airbnb-review.svelte';

export const client = new Client({
  
  /**
   * The Novu API key is needed for when you
   * need to sync to Novu Cloud
   */
  apiKey: process.env.NOVU_API_KEY,
  /**
   * Disable this flag only during local development
   * For production this should be true
   */
  strictAuthentication: process.env.NODE_ENV !== "development"
});

export const svelteWorkflow = workflow('airbnb-review', async ({ step, payload }) => {
    await step.email(
        'send-email',
        async (inputs) => {
            const html = render({
                template: AirbnbReview,
                props: {
                    authorName: inputs.authorName,
                    showFeedbackButton: inputs.showFeedbackButton,
                    showLogoImage: inputs.showLogoImage,
                    feedbackButtonText: inputs.feedbackButtonText,
                    bottomAddress: inputs.bottomAddress,
                    authorImage: inputs.authorImage,
                    logoImage: inputs.logoImage
                },
            });
            return {
                subject: `Here's Your Host Feedback`,
                body: html,
            }
        }, {
            inputSchema: {
                type: "object",
                properties: {
                  showFeedbackButton: { type: "boolean", default: true },
                  showLogoImage: { type: "boolean", default: true },
                  authorName: { type: "string", default: "Alex" },
                  feedbackButtonText: { type: "string", default: "Send My Feedback" },
                  authorImage: {
                    type: "string",
                    default: "https://react-email-demo-bdj5iju9r-resend.vercel.app/static/vercel-user.png",
                    format: "uri",
                  },
                  logoImage: {
                    type: "string",
                    default: "https://svelte-email-rjaapma15-konzeptfabrik.vercel.app/airbnb-logo.png",
                    format: "uri",
                  },
                  bottomAddress: {
                    type: "string",
                    default: "Airbnb, Inc., 888 Brannan St, San Francisco, CA 94103",
                  },
                },
            },
        });
    }
);
```

### 5. Preview Email Workflow & Sync to Novu Cloud

Open Dev Studio to preview and make changes to the email workflow as needed via the command below:

```jsx theme={null}
npx novu-labs@latest echo
```

1. Run the Studio

<Frame>
  <img />
</Frame>

**Note:** Use the port on which your Svelte app is running for the Bridge endpoint so that the Novu Dev Studio can connect to your API route.

2. Check out the email workflow and test

<Frame>
  <img />
</Frame>

3. Deploy to Novu Cloud when you're done.

On the top right of the Novu Dev Studio, you can sync to Novu Cloud when you're done working locally.

**Note:** You'll need to create a local tunnel that the Novu Cloud environment can reach for local experimentation purposes. Ngrok is a good tunnel.

### 6. Send a Notification

Trigger a notification using the recently deployed workflow either via your [Novu Cloud dashboard](https://web.novu.co) or [code](/quickstarts/react#trigger-a-notification).

Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows.


# How to send OTP verification email notifications with React-email
Source: https://v0.x-docs.novu.co/guides/framework-guides/otp

Learn how to send OTP verification email notifications with React-email in your NextJS app

## Introduction

In this guide, you’ll learn how to send OTP verification email notifications using the React-email package. Follow these steps:

## Getting started

Integrating Novu’s code-first workflow with React.Email for your Next.js application can be done in a few steps:

1. Create a NextJS app and wait for the installation:

```bash theme={null}
npx create-novu-app@latest --api-key=<YOUR_API_KEY>

// The command will ask you if you want to include react-email into your new project.
```

2. Once this installation is complete, simply `cd` into the directory and start your app using the `npm run dev` command.

## Using a code-first workflow

1. Write an email template - To write an email template, you can look over some of the examples in the [React Email](https://react.email/examples) documentation to get inspiration. In our case, this is the template:

```ts theme={null}
import {
    Body,
    Button,
    Container,
    Head,
    Heading,
    Hr,
    Html,
    Img,
    Link,
    Preview,
    Section,
    Text,
    render
} from "@react-email/components";
import * as React from "react";

interface LinearLoginCodeEmailProps {
    validationCode?: string;
    showJoinButton?: boolean;
    buttonText?: string;
    inviteLink?: string;
    logoURL?: string;
    inviteFromLocation?: string;
    inviteFromIp?: string;
    supportEmail?: string;
}

export const LinearLoginCodeEmail = ({
    validationCode,
    showJoinButton,
    buttonText,
    inviteLink,
    logoURL,
    inviteFromIp,
    inviteFromLocation,
    supportEmail
}: LinearLoginCodeEmailProps) => (
    <Html>
        <Head />
        <Preview>Your login code for Linear</Preview>
        <Body style={main}>
            <Container style={container}>
                <Img
                    src={`${logoURL}`}
                    width="42"
                    height="42"
                    alt="Linear"
                    style={logo}
                />
                <Heading style={secondary}>
                    Your login code for Linear
                </Heading>
                <Section style={buttonContainer}>
                    {showJoinButton && (
                        <Section className="text-center mt-[32px] mb-[32px]">
                            <Button
                                style={button}
                                href={inviteLink}
                            >
                                {buttonText}
                            </Button>
                        </Section>
                    )}
                </Section>
                <Text style={paragraph}>
                    This link and code will only be valid for the next 5 minutes. If the
                    link does not work, you can use the login verification code directly:
                </Text>
                <Section style={codeContainer}>
                    <Text style={code}>{validationCode}110658</Text>
                </Section>
                <Hr style={hr} />
                <Text style={paragraphSupport}>Not expecting this email?</Text>
                <Text style={paragraphSupport}>
                    This invite was
                    sent from <span style={paragraphSupportText}>{inviteFromIp}</span>{" "}
                    located in{" "}
                    <span style={paragraphSupportText}>{inviteFromLocation}</span>.
                </Text>
                <Text style={paragraphSupport}>
                    Please contact{" "}
                    <Link href="mailto:suport@linear.com" style={link}>
                        {supportEmail}
                    </Link>{" "}
                    if you did not request this code.
                </Text>
            </Container>
        </Body>
    </Html>
);

LinearLoginCodeEmail.PreviewProps = {
    validationCode: "tt226-5398x",
} as LinearLoginCodeEmailProps;

export default LinearLoginCodeEmail;

const logo = {
    borderRadius: 21,
    width: 42,
    height: 42,
};

const main = {
    backgroundColor: "#ffffff",
    fontFamily:
        '-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen-Sans,Ubuntu,Cantarell,"Helvetica Neue",sans-serif',
};

const container = {
    margin: "0 auto",
    padding: "20px 0 48px",
    maxWidth: "560px",
};

const secondary = {
    color: "#000",
    display: "inline-block",
    fontFamily: "HelveticaNeue-Medium,Helvetica,Arial,sans-serif",
    fontSize: "20px",
    fontWeight: 500,
    lineHeight: "24px",
    marginBottom: "0",
    marginTop: "2rem",
    textAlign: "center" as const,
};

const paragraphSupportText = {
    fontSize: "15px",
    fontWeight: "700",
};

const paragraph = {
    margin: "0 0 15px",
    fontSize: "15px",
    lineHeight: "1.4",
    color: "#3c4149",
};

const buttonContainer = {
    padding: "27px 0 27px",
};

const button = {
    backgroundColor: "#5e6ad2",
    borderRadius: "3px",
    fontWeight: "600",
    color: "#fff",
    fontSize: "15px",
    textDecoration: "none",
    textAlign: "center" as const,
    display: "block",
    padding: "11px 23px",
};

const hr = {
    borderColor: "#dfe1e4",
    margin: "42px 0 26px",
};

const code = {
    color: "#000",
    display: "inline-block",
    fontFamily: "HelveticaNeue-Bold",
    fontSize: "16px",
    fontWeight: 700,
    letterSpacing: "6px",
    lineHeight: "40px",
    paddingBottom: "8px",
    paddingTop: "8px",
    margin: "0 auto",
    width: "100%",
    textAlign: "center" as const,
};

const paragraphSupport = {
    color: "#444",
    fontSize: "15px",
    fontFamily: "HelveticaNeue,Helvetica,Arial,sans-serif",
    letterSpacing: "0",
    lineHeight: "23px",
    padding: "0 40px",
    margin: "0",
    textAlign: "center" as const,
};

const link = {
    color: "#444",
    textDecoration: "underline",
};

const codeContainer = {
    background: "rgba(0,0,0,.05)",
    borderRadius: "4px",
    margin: "16px auto 14px",
    verticalAlign: "middle",
    width: "280px",
};

export function renderOTPEmail(payload: any) {
    return render(<LinearLoginCodeEmail {...payload} />);
}
```

2. Launch Dev Studio - Novu’s code-first approach lets you see how the template would look when rendered, right when defining it, using the Dev Studio. To launch the dev studio locally you can run `npx novu-labs@latest echo`. The Dev Studio will be started by default on port 2022, and accessible via: [http://localhost:2022](http://localhost:2022)

<Frame>
  <img />
</Frame>

3. Define a workflow that uses that template to send notifications - In this step, we need to define a workflow that uses the template we wrote above to render the email notification:

```ts theme={null}
import { Client, workflow } from "@novu/framework";
import { renderOTPEmail } from "./otp";

export const client = new Client({
  apiKey: process.env.NOVU_API_KEY,
  /**
   * Disable this flag only during local development
   */
  strictAuthentication: process.env.NODE_ENV !== "development",
});

export const otpFlow = workflow('otp-flow', async ({ step, payload }) => {
  // Send a welcome email
  await step.email('send-email', async (inputs) => {
    return {
      subject: `Here's your verification code, Sumit!`,
      body: renderOTPEmail(inputs, payload),
    };
  }, {
    inputSchema: {
      type: "object",
      properties: {
        showJoinButton: { type: "boolean", default: true },
        buttonText: { type: "string", default: "Login to Linear" },
        logoURL: {
          type: "string",
          default: "https://react-email-demo-7qy8spwep-resend.vercel.app/static/linear-logo.png",
          format: "uri",
        },
        supportEmail: { type: "string", default: "support@linear.co" },
        validationCode: { type: "string", default: "tt226-5398x" },
        inviteLink: {
          type: "string",
          default: "https://linear.app",
          format: "uri",
        },
        inviteFromIp: { type: "string", default: "204.13.186.218" },
        inviteFromLocation: {
          type: "string",
          default: "São Paulo, Brazil",
        },
      },
    },
  });
  // JSON Schema for validation and type-safety. Zod, and others coming soon.
}, { payloadSchema: { properties: { text: { type: 'string' } } } });
```

4. Triggering the workflow - Lastly, we need to trigger the workflow we created above. Here’s how to trigger it:

```ts theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

export async function POST(request: Request) {
  const res = await request.json();

  await novu.trigger('otp-flow', {
    to: {
      subscriberId: 'new-user',
    },
    payload: {
      email: res.email,
      username: res.username,
    },
  });

  console.log('triggered')
  return Response.json({ success: true });
}
```

When we trigger this workflow, here’s the email received on the client-side:

<Frame>
  <img />
</Frame>

That’s it!

That’s how you create and use an OTP workflow. You can check out [our docs](https://docs.novu.co/guides/framework-guides/framework-react-email) for a hands on guide with more in-depth instructions.

Once you've built the workflow, you might want read one of [our other guides](/guides/framework-guides/product) on how to empower product teams to manage notification workflows.

Don’t forget to share your workflows with us and as always, hit us up on Discord with any questions you might have!


# Empowering Product Teams to Manage Notification Workflows
Source: https://v0.x-docs.novu.co/guides/framework-guides/product

Enabling product teams to independently manage and optimize notification workflows for improved efficiency and user experience

# Introduction

Novu’s code-first workflow empowers product teams to manage notification for end-users independently once the engineering teams have built and delivered the notification platform for the product.

Let’s see how product teams can leverage it:

1. **Engineering Team sets things up:** Engineering teams integrate Novu’s code-first workflows into their application. This involves setting up the structure of notification workflows in the codebase, defining events, steps, inputs, payload, etc. These workflows are functions that execute business logic and need to be set only once.
2. **Empowering Non-Technical Teams:** Once the foundational workflows are established, product teams can take over! Code-first workflows allow non-technical users to modify workflows safely without breaking critical integrations. Through an exposed Inputs interface, product teams can adjust notification content and behaviour, tailoring the user experience without needing to dive into the code at all. This helps both teams win - product teams are empowered to manage and optimize notifications independently, creating a dynamic and user-centric notification system without constant reliance on engineering teams.
3. **Insights and Optimization**: Further, with Novu’s Web Dashboard, Product teams gain valuable insights into last-mile delivery from the activity monitor. This enables them to refine notification strategies and optimize for better user satisfaction.

This collaborative approach between the Engineering and Product teams allows both teams to focus on their strengths, resulting in a more efficient and effective notification strategy, without constant interruptions in each other’s flow.

## Customising the workflow

To demonstrate the customizability, we’ll assume that the Engineering team has successfully delivered the basic setup as outlined in [one of our guides.](https://docs.novu.co/guides/framework-guides/framework-react-email)

1. To start things off, you only need to visit the workflow section in our [Web Dashboard](https://web.novu.co/).

<Frame>
  <img />
</Frame>

* You’ll see the blue lightning bolt icon right next to the workflow name symbolising that it is a code-first workflow.
* Now, simply click on the workflow to open it and make your desired changes.
* The green `Sync` indicator on the top right corner means that your app is successfully connected with Novu.

2. Once you open a workflow, you’ll see all the steps of the workflow:

<Frame>
  <img />
</Frame>

3. Simply, select a node to see the rendered view. This is what will get sent to the end user.

<Frame>
  <img />
</Frame>

4. To start making changes, simply click on either of the two buttons highlighted below:

<Frame>
  <img />
</Frame>

5. Once you click on it, you’ll be taken to the edit view where you’ll see real-time preview of the workflow. You can make changes to the step inputs on the right-hand side and the rendered view will update in real-time to reflect those changes

<Frame>
  <img />
</Frame>

6. Let's take a look at what payload and step inputs are:
7. In almost all the scenarios, you’ll be tweaking and modifying step inputs and the workflow editor makes it blazing fast and effortlessly simple. Simply change the text of the respective field or button or toggle any button on or off till the rendered view becomes what you want your end users to receive. Here’s how you can tweak it:

<Frame>
  <img />
</Frame>

## Conclusion

The collaboration resulting from Novu’s code-first workflow increases agility, enabling rapid iterations and quick adjustments based on user feedback. It fosters effective collaboration between product and engineering teams, resulting in a more efficient workflow and improved user notifications.


# How to use Headless Notification Center
Source: https://v0.x-docs.novu.co/guides/headless-notification-center-guide

Use the headless version of the notification center

## Introduction

In this guide, you'll learn about how to use the headless version of our notification center. The headless version is useful for scenarios in which a lightweight solution for integrating notification functionality into a web app that is completely unstyled (so that you can style it as per your wish) is required.

<br />

You can find the entire code ( front-end as well as back-end ) of this app [here.](https://github.com/novuhq/novu-headless-demo-app)

## What is the headless notification center

The headless version of Novu's notification library package provides users with a lightweight solution for integrating notification functionality into their web applications.

<br />

With just the essential API methods, users can easily incorporate our notification system into any framework or vanilla JavaScript project, without being constrained by our default UI or dependencies.

This gives the users of the headless notification center greater flexibility and control over what the end-users of a product see and experience.

## How to use the headless notification center

To get started with this you need:

1. A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-guides-headless) if you don’t have one yet.
2. A working dev environment in the framework of your choice (or vanilla JS). Here, we'll use a React environment

## Workflow set up in Novu

Once, you have signed up for Novu and have a dev environment, follow the steps below:

1. Head over to the Novu Dashboard.
2. Click `Workflows` on the left sidebar of your Novu dashboard.
3. Click the `Create Workflow` button on the top right:

<Frame>
  <img />
</Frame>

Once you click the `create workflow` button, you’ll see a dropdown. Select `blank workflow` from the dropdown:

<Frame>
  <img />
</Frame>

You’ll now be taken to the workflow editor:

<Frame>
  <img />
</Frame>

Once here, you can add the channels you want to use for sending notifications and configure them. For this guide, we’ll use the `In-App` channel.

<Frame>
  <img />
</Frame>

The `In-app` node allows you to further customize the notifications that will get sent, as per your need. In our case, it is a simple `description`, which will contain the text that will be entered from the front end. Here's the `in-app` node for your reference:

<Frame>
  <img />
</Frame>

Here's a brief overview of all the options:

* **1-Preview**: This shows you a glimpse of what each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.

Once you’re done configuring this to your liking, click on the `update` button on the top right. It'll automatically create a trigger code that you can use in your app. To get it, click on the `get snippet` button on the top right and copy it:

<Frame>
  <img />
</Frame>

<br />

Let's now see how to add it to our app!

## Pre-requisites:

To be able to use the headless notification center, you'll first need the following:

1. `applicationIdentifier`: You can find this from the `settings` menu in the [Novu web dashboard.](https://web.novu.co/settings?utm_campaign=docs-guides-headless)
2. `subscriberID`: In most real-world apps, you'll get this from a database. It is used to uniquely identify the entity to whom a notification will be delivered. In our case, we're assuming the `subscriberID` to be `12345`.

## Setting up the back end:

For our demo app, we're setting up the back end as follows:

1. Install the Novu package. Open your terminal and run the following command:

```bash theme={null}
npm install @novu/node
```

Once installed, you can import Novu into your app and initialize it using your Novu account credentials. This step establishes a connection between your app and the Novu notification service.

```bash theme={null}
import { Novu } from '@novu/node';
const novu = new Novu('<NOVU_API_KEY>');
```

<Note>
  Replace the `<NOVU_API_KEY>` value with the authentic key from the API Key section of your [Novu Dashboard.](http://web.novu.co/?utm_campaign=docs-guides-headless)
</Note>

<Note>
  🔑 Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

Using the above info, we'll write a function that will help us interact with Novu's notification system:

```javascript theme={null}
import { Novu } from '@novu/node';

export const notification = async (description) => {
    const novu = new Novu("<NOVU_API_KEY>");
    await novu.subscribers.identify(process.env.SUSBSCRIBER_ID, {
        firstName: 'newSubForHeadless',
    });

// code snippet copied when creating the workflow
    await novu.trigger('headless-demo', {
        to: {
            subscriberId: process.env.SUSBSCRIBER_ID
        },
        payload: {
            description: description
        }
    });

}
```

After this, we'll set up a simple controller function for handling notifications:

```javascript theme={null}
import { notification } from "../novu/novu.js";

export const notifController = async (req,res) => {
    const{description} = req.body;
    try {
        await notification(description)
        res.status(201).json({message:"Subscriber created successfully"});
    } catch (error) {
        console.log("notifController error:",error);
        res.status(500).json({message: error.message})
    }
}
```

And finally, we'll need to establish routes that we'll hit from the front end:

```javascript theme={null}
import express from "express";
import { notifController } from "../controller/notif.js";

const router = express.Router();

router.post("/create-sub",notifController);

export default router;
```

Now, we'll move to the front end because that's where all the magic happens!

## Setting up the front end:

In the front end, install the headless package:

```bash theme={null}
npm install @novu/headless
```

Then, import it and initialize the headless service:

```javascript theme={null}
import { HeadlessService, FetchResult, ISession } from '@novu/headless';

 useEffect(() => {

        const headlessService = new HeadlessService({
            applicationIdentifier: 'SWMw97ec1ZNA',
            subscriberId: '12345',
        });

        headlessService.initializeSession({
            listener: (res) => {
            },
            onSuccess: (session) => {
                headlessServiceRef.current = headlessService;
                fetchNotifications();
            },
            onError: (error) => {
                console.log("headlessSice error:", error);
            },
        })

    }, [fetchNotifications])
```

We've added the `fetchNotifications` function inside a useEffect because we want the effect to run whenever the `fetchNotifications` executes. Here's the `fetchNotifications` function for reference:

```javascript theme={null}
const fetchNotifications = useCallback(() => {
        const headlessService = headlessServiceRef.current;
        if (headlessService) {
            headlessService.fetchNotifications({
                listener: ({ data, error, isError, isFetching, isLoading, status }) => {
                    // Handle the state of the fetching process and errors here.
                },
                onSuccess: (response) => {

                    // Handle the fetched notifications here.
                    setNotifications(response.data); // Store notifications in the state
                },
                page: pageNum, // page number to be fetched
            });
        }
    }, [pageNum])
```

Here, we've memoized the `fetchNotifications` to optimize performance and passed `pageNum` in a dependency array so that it reruns when the page number changes.

<br />

You can refer to the entire context [here](https://github.com/novuhq/novu-headless-demo-app/blob/main/frontend/src/context/NotificationContext.js) for a better understanding.

We've also used several methods related to the Headless Notification Center package. You can find the complete list [here.](/notification-center/client/headless/api-reference)

The methods that we've used in our app are `markNotificationsAsRead`, `deleteNotification`, and `markAllMessagesAsRead`. They are as follows:

```javascript theme={null}

    const markNotificationsAsRead = (messageIds) => {
        if (!Array.isArray(messageIds)) {
            messageIds = [messageIds];
        }

        const headlessService = headlessServiceRef.current;

        if (headlessService) {
            headlessService.markNotificationsAsRead({
                messageId: messageIds,
                listener: (result) => {
                },
                onError: (error) => {
                    console.error('Error marking notifications as read:', error);
                },
            });
        }

    };


const deleteNotification = (messageId) => {
        const headlessService = headlessServiceRef.current;
        if (headlessService) {
            headlessService.removeNotification({
                messageId: messageId,
                listener: function (result) {
                },
                onSuccess: function (message) {
                },
                onError: function (error) {
                    console.error(error);
                },
                messageIds: 'messageOne',
            });

        }
    }

    const markAllMessagesAsRead = (feedId) => {
        const headlessService = headlessServiceRef.current;

        headlessService.markAllMessagesAsRead({
            listener: (result) => {
                console.log(result);
                // Handle the result of marking all messages as read
                // You can update the state or perform other actions here
            },
            onError: (error) => {
                console.error('Error marking all messages as read:', error);
                // Implement error handling if needed
            },
            feedId: feedId, // Pass the feed ID here, it can be an array or a single ID
        });
    };
```

<Note>
  You can view the entire API reference [here](/notification-center/client/headless/api-reference) and pick up the methods that you'd like to use for your specific requirements.
</Note>

### Coding the UI up:

On the UI front, we have a simple form with a submit handler function and a couple of components:

```javascript theme={null}
const Body = () => {

    const [description, setDescription] = useState('');
    const { active, setActive } = useNotification();
    const onSubmitHandler = async e => {
        e.preventDefault()
        await axios.post('https://headless-backend-qx89.onrender.com/api/v1/create-sub', { description })

        setDescription('')
        setActive(true)
    }
    const onChangeHandler = e => {
        setDescription(e.target.value);
    }
    return (
        <div className='body-container'>
            <p>Enter notification text</p>
            <form onSubmit={onSubmitHandler} className="input-form">
                <input className="input" value={description} onChange={onChangeHandler} placeholder="Enter notification text" />
                <button className="form-btn">Send</button>
            </form>
        </div>
    )
}
```

The first component is the `appBar` component which includes a bell icon, which can show notifications in a modal when clicked. The modal is displayed when showModal is true, and the modal can be closed by clicking outside of it. The component interacts with the notification-related functionalities provided by the useNotification hook:

```javascript theme={null}
const AppBar = () => {
    const [showModal, setShowModal] = useState(false);
    const modalRef = useRef(null);

    const { fetchNotifications, setActive, active } = useNotification();

    const handleShowNotification = async (e) => {
        e.stopPropagation();
        setShowModal((prev) => !prev);
        await fetchNotifications();
        setActive(false);
    };
    const handleCloseModal = () => {
        setShowModal(false);
    }
    useEffect(() => {
        const handleDocumentClick = e => {
            if (modalRef.current && !modalRef.current.contains(e.target)) {
                handleCloseModal();
            }
        }
        if (showModal) {
            document.addEventListener('click', handleDocumentClick);
        }
        return () => {
            document.removeEventListener('click', handleDocumentClick)
        }
    }, [showModal])

    return (
        <div>
            <div className='app-bar-container'>
                <span onClick={handleShowNotification} className='bell-icon'>
                    <BsBell />
                    <div className={`${active ? `active` : ''}`}>
                        <div className='dot'></div>
                    </div>
                </span>
            </div>
            <div className={`modal-div ${showModal ? 'modal-show' : ''}`} ref={modalRef}>
                {showModal && (<NotificationModal />)}
            </div>
        </div>
    );
};

export default AppBar;
```

And the second component is the `NotificationModal` which is what gets displayed when the user clicks on the bell icon.

<Note>
  The beauty of using the headless version of the notification center is that you can customise exactly how it looks and which functionalities you need in it.
</Note>

Our `NotificationModal` component is as follows:

```javascript theme={null}
const NotificationModal = () => {

    const { notifications, markNotificationsAsRead, markAllMessagesAsRead, deleteNotification, setPageNum, pageNum, fetchNotifications } = useNotification();

    const handleNotificationRead = (notificationId) => {
        markNotificationsAsRead(notificationId);
    }

    const handleNotificationDelete = (notificationId) => {
        let newClass = document.getElementById(`${notificationId}`);
        newClass.style.display = 'none';
        deleteNotification(notificationId);
    }

    const handleMarkAllAsRead = () => {
        markAllMessagesAsRead();
    }
    const onPrvHandler = () => {
        setPageNum((prv) => prv - 1)

    }
    const onNxtHandler = () => {
        setPageNum((prv) => prv + 1)

    }


    useEffect(() => {
        fetchNotifications();
    }, [pageNum, fetchNotifications])
    return (
        <div className='bell-container'>
            <div className='heading'>
                <div className='title'>
                    <h2>
                        Notifications
                    </h2>
                </div>
                <div className='control-btn'>
                    <button className='modal-btn all-read title-btn' onClick={handleMarkAllAsRead}>Mark all as read</button>
                    <button className={` ${pageNum === 0 ? '' : 'modal-btn title-btn'}`} onClick={onPrvHandler} disabled={pageNum === 0 ? true : false}>Previous</button>
                    <button className={` ${notifications.length < 10 ? '' : 'modal-btn title-btn'}`} onClick={onNxtHandler} disabled={notifications.length < 10 ? true : false}>Next</button>
                </div>
            </div>
            <div>
                {notifications.map(not => (
                    <div key={not.id} className={`individual-notif`} id={`${not.id}`}>
                        <>
                            <span className={`bell-notif ${not.read ? 'read' : ''}`}>
                                {not?.payload?.description}
                            </span>
                            <div className='btn-container'>
                                {!not?.read && (
                                    <button onClick={() => handleNotificationRead(not?.id)} className='read-btn classic-btn'>Read</button>
                                )}
                                <button onClick={() => handleNotificationDelete(not?.id)} className='delete-btn classic-btn'>Delete</button>
                            </div>
                        </>
                    </div>
                ))
                }
            </div>
        </div>
    )
}
```

Finally, we've used some css to style the app to our liking. You can see that [here.](https://github.com/novuhq/novu-headless-demo-app/tree/main/frontend/src/styles).

## Conclusion

If you've followed everything till here, you'll end up with an app like the following:

<Frame>
  <img />
</Frame>

Again, don't forget that you can view the entire code [here](https://github.com/novuhq/novu-headless-demo-app/tree/main) and if you've any questions, either related to this headless app or something else, feel free to ping use [here.](https://discord.gg/novu)
Also, we've several demo apps for you to check out [here.](/demos/introduction)
Thanks for reading!


# How To Integrate Segment With Novu
Source: https://v0.x-docs.novu.co/guides/how-to-integrate-segment-with-novu



[Segment](https://segment.com/) is a customer data platform that helps businesses collect, manage, and analyze customer data from multiple sources. It streamlines data integration, ensures data quality, and aids in compliance with regulations. Segment's tools enable better understanding of customer behavior and facilitate personalized customer experiences. It's useful for marketing, analytics, and product teams in diverse industries.

If this is your first time working with the tool, consider consulting the 'Get Started' guide in [Segment's official documentation](https://segment.com/docs/getting-started/).

## Examples Use Case

**Enhancing Customer Engagement and Conversion Rates**

<Steps>
  <Step title="Data Integration with Segment">
    * The e-commerce platform uses Segment to collect and unify customer data from various sources like website visits, purchase history, and customer interactions.
    * Segment helps in creating a unified customer profile by consolidating data from different touchpoints – mobile app usage, website browsing patterns, and previous purchase behavior.

    <iframe title="YouTube video player" />
  </Step>

  <Step title="Behavioral Analysis and Segmentation">
    * The data collected is analyzed to understand customer preferences, buying patterns, and engagement levels.
    * Customers are segmented into different groups based on their behavior, interests, and purchase history. For instance, one segment might include frequent shoppers, while another might focus on those who browse but rarely purchase.

    <iframe title="YouTube video player" />
  </Step>

  <Step title="Personalized Notification with Novu">
    * Novu is used to craft and send personalized notifications to these segmented groups.
    * For frequent shoppers, notifications about new arrivals or exclusive deals might be sent. For those who browse but rarely buy, notifications could include special discount codes or reminders about items left in the cart.

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Trigger-Based Notifications">
    * Notifications can also be triggered based on specific customer actions. For example, if a customer views a product but doesn't make a purchase, they might receive a notification later highlighting a special offer on that product.

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Feedback Loop for Continuous Improvement">
    * Customer responses to these notifications are fed back into Segment. This data is used to refine customer profiles and segmentation strategies continuously.
    * The effectiveness of different types of notifications is analyzed to optimize future communication.
  </Step>
</Steps>

**Outcome:**

* Enhanced customer engagement through personalized and timely notifications.

* Improved conversion rates by targeting customers with relevant offers based on their behavior and preferences.

* Greater customer loyalty due to a tailored shopping experience.

## Setting Novu as a Destination

As of <Tooltip>today</Tooltip> Segment doesn’t have a native Novu Destination integration **yet** .

We will be using [Destination Functions](https://segment.com/docs/connections/functions/destination-functions/). Destination functions allow you to transform and annotate your Segment events and send them to any external tool or API without worrying about setting up or maintaining any infrastructure.

### Create a destination function

* From your workspace, go to `Connections > Catalog` and click the `Functions` tab.
* Click `New Function`.
* Select `Destination` as the function type and click `Build`.
* After you click `Build`, a code editor appears. Use the editor to write the code for your function, configure settings, and test the function’s behavior.

<Tip>Want to see some example functions? Check out the templates available in the Functions UI, or in the open-source Segment Functions Library.</Tip>

### Code the destination function

Segment invokes a separate part of the function (called a “handler”) for each event type that you send to your destination function.

<Note> Your function isn’t invoked for an event if you’ve configured a destination filter, and the event doesn’t pass the filter. </Note>

The default source code template includes handlers for all event types. You don’t need to implement all of them - just use the ones you need, and skip the ones you don’t.

Destination functions can define handlers for each message type in the Segment spec:

* onIdentify
* onTrack
* onPage
* onScreen
* onGroup
* onAlias
* onDelete
* onBatch

Each of the functions above accepts two arguments:

`event` - Segment event object, where fields and values depend on the event type.
For example, in “Identify” events, Segment formats the object to match the Identify spec.

`settings` - Set of settings for this function.
The example below shows a destination function that listens for “Track” events, and sends some details about them to an external service.

```javascript theme={null}
async function onTrack(event) {
  await fetch('https://example-service.com/api', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      event_name: event.event,
      event_properties: event.properties,
      timestamp: event.timestamp
    })
  })
}
```

To change which event type the handler listens to, you can rename it to the name of the message type.

For example, if you rename this function `onIdentify`, it listens for “Identify” events instead.

<Tip>
  If you you need an example of Novu destination function, you can find it in [here](https://github.com/novuhq/segment-novu-destination-scripts).
  Feel free to submit your function examples as well!
</Tip>

### Sending a payload to Novu

Now let's learn how to send a payload to Novu based on the `onTrack` event function:

To successfully send a payload to Novu, triggering the appropriate [workflow](/getting-started/concepts#workflow) and delivering it to the correct customer, please ensure that you provide the following information:

1. Novu's Workflow Identifier.
2. Subscriber ID (Please ensure that the Subscriber ID is both unique and consistent across all of your databases).
3. Your Novu API Key.
4. [Novu's Event Trigger API Endpoint](https://api.novu.co/events/trigger)

```javascript theme={null}
async function onTrack(event, settings) {
	const eventProperties = event.properties;

	if (!eventProperties.environment) {
		throw new InvalidEventPayload('environment property is required');
	}
	if (!eventProperties.name) {
		throw new InvalidEventPayload('Workflow name property is required');
	}

	console.log('environment:', eventProperties.environment);

	const payload = {
		name: eventProperties.name,
		to: {
			subscriberId: eventProperties.user.subscriberId,
			email: eventProperties.user.email,
			firstName: eventProperties.user.firstName,
			lastName: eventProperties.user.lastName
		},
		payload: { eventProperties }
	};
	const endpoint = settings.novuEndpoint;
	console.log('endpoint:', endpoint);

	const ApiKey = settings.novuApiKey; // Your NOVU API key
	if (eventProperties.environment === settings.environment) {
		let response;
		try {
			response = await fetch(endpoint, {
				method: 'POST',
				headers: {
					Authorization: `ApiKey ${ApiKey}`,
					'Content-Type': 'application/json'
				},
				body: JSON.stringify(payload)
			});
		} catch (error) {
			// Retry on connection error
			throw new RetryError(error.message);
		}
		if (response.status >= 500 || response.status === 429) {
			// Retry on 5xx (server errors) and 429s (rate limits)
			throw new RetryError(`Failed with ${response.status}`);
		}
	}
}
```

#### Create Settings and Secrets

Segment's settings allow you to pass configurable variables to your function, which is the best way to pass sensitive information such as security tokens. For example, you might use settings as placeholders to use information such as an API endpoint and API key.
You can learn more about it [here](https://segment.com/docs/connections/functions/destination-functions/#create-settings-and-secrets).

<Frame>
  <img />
</Frame>

Click `Add Setting` to add your new setting.

<Frame>
  <img />
</Frame>

Now, while configuring the function, Add these three variables to be then used in the code exposed in the settings function param.

<Frame>
  <img />
</Frame>

#### Test the destination function

You can test your code directly from the editor in two ways:

**1. Use sample events for testing**
Click `Use Sample Event` and select the source to use events from.

<Frame>
  <img />
</Frame>

Click `Run` to test your function with the event you selected.

**2. Test using manual input**
You can also manually include your own JSON payload of a Segment event, instead of fetching a sample from one of your workspace sources.

<Frame>
  <img />
</Frame>

**Here is the the event example JSON we will use**

```JSON theme={null}
{
  "type": "track",
  "event": "User Abandoned Cart",
  "properties": {
    "name": "abandoned-cart-recovery-workflow",
    "user": {
      "subscriberId": "63da8ee0c037e013fd790ffd",
      "email": "hi@hi.com",
      "firstName": "John",
      "lastName": "Doe"
    },
    "environment": "development"
  }
}
```

We will now execute the function based on the manual event input we've provided. This function sends a trigger to Novu, prompting to take action and send the user an email to return and the purchase.

<Frame>
  <img />
</Frame>

Whether you chose the first or second option to test your Destination Function, you can also check if the function triggered your workflow and whether it was delivered through Novu's [Activity Feed](https://web.novu.co/activities?utm_campaign=docs-guides-segment).

<Frame>
  <img />
</Frame>

This guide was inspired by the following resources:

* [https://discord.com/channels/895029566685462578/1060308007658987571/1077377322547687475](https://discord.com/channels/895029566685462578/1060308007658987571/1077377322547687475)
* [https://segment.com/docs/getting-started/05-data-to-destinations/](https://segment.com/docs/getting-started/05-data-to-destinations/)
* [https://aviyel.com/post/3381/how-to-integrate-novu-with-segment](https://aviyel.com/post/3381/how-to-integrate-novu-with-segment)


# How to send push notifications in an Android app (react native) with FCM and Novu
Source: https://v0.x-docs.novu.co/guides/novu-fcm-react-native-android

Learn how to send FCM push notifications in a React native Android app using Novu and FCM

## Prerequisites

To complete this tutorial, you will need the following:

* A [Firebase](https://firebase.google.com/) account
* A [Novu](https://web.novu.co/?utm_campaign=docs-gs-guides-fcm-android) account
* An [Expo](https://expo.dev) account

Push notifications are notifications that are sent to a user’s devices whether the user is using the app or not. We’ll be using the Firebase Cloud Messaging (FCM) integration of Novu to send these notifications. You can find the complete code for this project in our [Github repo.](https://github.com/novuhq/fcm-react-native-android)

## Start a React-Native project

We'll use the `create-expo` tool to initialize a new expo app. It creates a new React Native app with the expo package installed. We're naming our app `fcm-novu-rn2` and hence using the following command:

```javascript theme={null}
 npx create-expo-app fcm-novu-rn2
```

<Info>If it asks you to choose a template, choose the 'blank' template.</Info>

Now, go to the project directory and install the `react-native-firebase` package using the following command:

```bash theme={null}
npm install --save @react-native-firebase/app
```

Once this is installed, install the messaging module of Firebase using the following command:

```bash theme={null}
npm i --save @react-native-firebase/messaging
```

## Getting the FCM token

Now, we need to grab the `token key` from FCM. We'll need this to send notifications using FCM. We're using `useEffect` to grab this key as follows:

```jsx theme={null}
// import messaging module
import messaging from '@react-native-firebase/messaging';

// Request permission to send notifications
const authStatus = await messaging().requestPermission();

// Check if permission is granted or provisional
const enabled =
  authStatus === messaging.AuthorizationStatus.AUTHORIZED ||
  authStatus === messaging.AuthorizationStatus.PROVISIONAL;

// If permission is granted or provisional, proceed
if (enabled) {
  // Log the authorization status
  console.log('Authorization status:', authStatus);

  // Retrieve the FCM token for the device
  const token = await messaging().getToken();
  // Log the FCM token
  console.log('FCM Token is:', token);

  // Return a function to unsubscribe from notifications
  return unsubscribe;
} else {
  // If permission is not granted, log the error status
  console.log('Could not grab token...', authStatus);
}

```

## FCM handlers

FCM uses something called a `background handler` to, as the name suggests handle notifications when the app is in the background. So, we'll add it to our app:

```jsx theme={null}
// Background message handler for incoming messages while the app is in bg
messaging().setBackgroundMessageHandler(async (remoteMessage) => {
  // Log a message indicating that a message was handled in the background
  console.log('Message handled in the background!', remoteMessage);
});

```

Similarly, we also need a `foreground handler` to handle notifications when the app is in the foreground. In our case, we're updating a state's value in our handler. Here's our foreground handler:

```jsx theme={null}
// handle incoming messages while the app is in the foreground
const unsubscribe = messaging().onMessage(async (remoteMessage) => {
  // Log a message indicating that the onMessage event is working
  console.log('working!!!!');
  
  // Update state with the received message
  setNotification(remoteMessage);
});
return unsubscribe;
```

## Setting up Expo

In order to load projects from Expo CLI, we need a dev client to be installed in our app. To install it, execute the following command from the root of the project directory:

```bash theme={null}
 npx expo install expo-dev-client
```

Once installed, log into your expo account using the following command:

```bash theme={null}
eas login
```

It'll ask for your username and password and log you in.

Now, we are ready to create our build of the app. Use the following command to create a development build of the app for the Android platform:

```bash theme={null}
eas build --profile development --platform android
```

<Info>If expo asks if you want to automatically create an EAS project for your app, choose yes. Do the same when it asks you if you want to generate a new keystore.</Info>
<Warning>Do not change the Android package name, even if EAS asks you to!</Warning>

## Setting up Firebase

1. Create a Firebase account if you don't already have one. Then, create a new project and all the relevant details.

<Frame>
  <img />
</Frame>

2. Once your project has been created, you'll be greeted with this welcome screen and asked to add Firebase to your app, so let's do that.

<Frame>
  <img />
</Frame>

3. We'll choose the 'Android' option because we're creating an Android app.

<Frame>
  <img />
</Frame>

4. Find the package name from the `app.json` file of the project:

<Frame>
  <img />
</Frame>

5. Add this package name to Firebase:

<Frame>
  <img />
</Frame>

6. Now, we need to add `SHA1` keys from our project to the Firebase app. Run the following command to obtain `SHA1` key. We'll get two `SHA1` keys, one of which we'll add to Firebase right now and the other one, later on.

```bash theme={null}
eas credentials
```

<Info>If it asks you to, choose the 'Android' platform then 'Development' build then 'Keystore' then 'Set up a new keystore' then 'Select Build Credentials' and then 'Create a new build credential configuration'.</Info>

<Frame>
  <img />
</Frame>

7. Now copy the `SHA1` key and add it to Firebase and register the app:

<Frame>
  <img />
</Frame>

8. Click 'next' on all the other options and finally click 'continue to console' as follows:

<Frame>
  <img />
</Frame>

9. Go to 'project settings' and scroll all the way down

<Frame>
  <img />
</Frame>

10. Click on the 'Add fingerprint' button and add the second `SHA1` key here.

<Frame>
  <img />
</Frame>

11. Now, download the Google services file and add it to the project's root directory. We also need to specify its location in the `app.json` file:

<Frame>
  <img />
</Frame>

12. Now we need to upload the Firebase server key to expo. Go to project settings and find it under the 'Cloud Messaging' tab.

<Frame>
  <img />
</Frame>

13. Now, upload that key to expo using the following command:

```bash theme={null}
expo push:android:upload --api-key <your server key here> 
```

14. Rebuild the app using the following command and we're good to go!

```bash theme={null}
eas build --profile development --platform android
```

15. If you have an Android device with you, simply scan and install the app. Otherwise, if you want to run it on an emulator, simply copy the link given alongside the QR code and open it on the emulator and then install the app.

16. Start the server to run the app, using the following command:

```bash theme={null}
npx expo start --dev-client
```

Again, you can either scan the QR code or copy and paste the link.

<Frame>
  <img />
</Frame>

<Warning>Sometimes it doesn't fire up the emulator even when you have it installed. In that case, start the emulator manually and run the server again!</Warning>

## Setting up Novu

We'll need a workflow to trigger notifications to our user's devices. Follow the steps below to create one to ensure we are on the path to making FCM work as expected:

1. Head over to the [Integrations Store](https://web.novu.co/integrations?utm_campaign=docs-guides-fcm-android) on the Novu Web Dashboard and make sure that you've turned on the 'Firebase Cloud Messaging' integration.

<Frame>
  <img />
</Frame>

<Info>If you're doing this for the first time, you'll need to get your service account key from the [Firebase Console](https://console.firebase.google.com/). Read more about it in our [FCM provider docs.](https://docs.novu.co/channels-and-providers/push/fcm)</Info>
2\. Now, we need to create a workflow that we'll trigger from our app to send notifications. Head over to [workflows in the Novu Web Dashboard](https://web.novu.co/workflows?utm_campaign=docs-guides-fcm-android) and click on the 'Add a workflow' button.

<Frame>
  <img />
</Frame>

3. Choose the 'blank workflow' option from the dropdown menu.

<Frame>
  <img />
</Frame>

3. Drag and drop the 'Push' node below the Workflow Trigger node.

<Frame>
  <img />
</Frame>

4. If you hover over the newly added 'Push' node, you'll see an error saying 'Message content and title are missing'.

<Frame>
  <img />
</Frame>

5. We're going to add a title and body for notifications. So, add them and give your workflow a suitable name.

<Frame>
  <img />
</Frame>

6. Now, click on the 'Update' and then the 'get snippet' button to get the trigger code.

<Frame>
  <img />
</Frame>

## Create a subscriber and update credentials

A subscriber is essentially the recipient of the notifications sent through Novu’s system. When you create a subscriber, you’re setting up the necessary information for Novu to send targeted notifications to. You can find more about subscribers in [our docs.](https://docs.novu.co/subscribers/subscribers)
To create a subscriber, we'll use the `identify` method:

```jsx theme={null}
// creating new instance of Novu
const novu = new Novu("<Novu API key>");

// creating subscriber
await novu.subscribers.identify('newSubForRNA', {
    firstName: "RNA"
});
```

Now, we'll add the FCM token that we'd received [earlier](#getting-the-fcm-token) to this subscriber using the `setCredentials` method:

```jsx theme={null}
await novu.subscribers.setCredentials('newSubForRNA', PushProviderIdEnum.FCM, {
    deviceTokens: ['<Enter the FCM token here>'],
});
// notice the use of 'newSubForRNA' here. This identifies the subscriber to which we're adding the FCM token
```

## Sending a push notification using Novu

To send a notification with Novu, we are actually triggering a notification workflow. Here's how to do it using Node:

```jsx theme={null}
novu.trigger('rna-2', {
    to: {
        subscriberId: 'newSubForRNA'
    },
    payload: {},
})
```

When triggered using the trigger code from above, this is the notification received on the device:

<Frame>
  <img />
</Frame>

## Dynamic content

So far, we've sent notifications that have had "hard-coded" content. Now we'll send dynamic data when triggering a notification.

The way to do so is by changing the values of the title and the body to `{{title}}` and `{{body}}` in our workflow.

1. Go to the workflow we'd created earlier and change the values of the title and the body to `{{title}}` and `{{body}}` respectively.

<Frame>
  <img />
</Frame>

2. Simply add these identifiers to the payload by changing the trigger code:

```jsx theme={null}
novu.trigger('rna-2', {
    to: {
        subscriberId: 'newSubForRNA'
    },
    payload: {
        title: payloadTitle,
        body: payloadBody
    },
});
```

<Note>We're extracting `payloadTitle` and `payloadBody` from the request body</Note>
Now, the notification delivered to the subscriber will contain dynamic data as shown below:

<Frame>
  <img />
</Frame>

## Sending images

Up to this point, your notifications have all contained only text. But if you’ve received many notifications, you know that notifications can have rich content, such as images. It’d be great if your notifications showed users a nice image related to their content. Once again, Firebase makes this super simple.

All you need to do is to specify the `URL` of the image in the override as shown below:

```jsx theme={null}
novu.trigger('rna-2', {
    to: {
        subscriberId: 'newSubForRNA'
    },
    payload: {
        title: payloadTitle,
        body: payloadBody
    },
    overrides: {
        fcm: {
            android: {
                notification: {
                    imageUrl: 'URL of the image',
                }
            }
        }
    }
});
```

The following notification is what gets delivered to the subscriber:

<Frame>
  <img />
</Frame>

## Handling data type messages

With FCM, you can send `Notification` and `Data` messages. We have handled sending notification messages. Let’s handle data messages. Data type messages are useful when, in addition to the usual data, you want to send some custom data. Maybe whether a subscriber has purchased the pro plan of our product or not, maybe which tier of usage they have purchased etc. You can do this easily by modifying the override. Here's an example of sending the subscription status using the identifier `subStatus`:

```jsx theme={null}
novu.trigger('rna-2', {
    to: {
        subscriberId: 'newSubForRNA'
    },
    payload: {
        title: payloadTitle,
        body: payloadBody
    },
    overrides: {
        fcm: {
            android: {
                    data: {
                        subStatus: "true"
                    },
            }
        }
    }
});
```

On the user's device, you can extract this out and have it displayed like this:

<Frame>
  <img />
</Frame>

## Priority of a notification

FCM tries to deliver high-priority messages immediately. The priority of a notification can also be altered by changing the overrides, as shown below:

```jsx theme={null}
novu.trigger('rna-2', {
    to: {
        subscriberId: 'newSubForRNA'
    },
    payload: {
        title: payloadTitle,
        body: payloadBody
    },
    overrides: {
        fcm: {
            android: {
                    data: {
                        subStatus: "true"
                    },
                    notification: {
                        priority: 'low'
                    }
            }
        }
    }
});
```

<Frame>
  <img />
</Frame>

## Additional resources

* [Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging)
* [FCM Architectural Overview](https://firebase.google.com/docs/cloud-messaging/fcm-architecture)


# How to send web push notifications with FCM and Novu
Source: https://v0.x-docs.novu.co/guides/novu-fcm-web

Send FCM push notifications in a React app using Novu

## Introduction

In this guide, we'll learn how to send FCM push notifications in a web app using Novu. But before exploring the actual code, let’s understand what a push notification is and how it works.
You can find the [frontend code](https://github.com/novuhq/fcmWebPushFE) as well as [backend code](https://github.com/novuhq/FCMWebPushBE) for the app on Github.

<br />

Push notifications are notifications that are sent to a user's devices whether the user is using the app or not. We'll be using Firebase Cloud Messaging (FCM) integration of Novu to send these notifications. This guide will be broken down into three parts:

1. Setting up Novu.
2. Setting up Firebase.
3. Adding Firebase to the Frontend.
4. Adding Novu to the Backend.

## Setting up Firebase

1. Create a Firebase account if you don't already have one. Then, create a new project and all the relevant details.

<Frame>
  <img />
</Frame>

2. Once your project has been created, you'll be greeted with this welcome screen and asked to add Firebase to your app, so let's do that.

<Frame>
  <img />
</Frame>

3. We'll choose the web option because we're creating a web app.

<Frame>
  <img />
</Frame>

4. Give your app a name and click on the 'Register' button.

<Frame>
  <img />
</Frame>

5. We're done with the Firebase setup! Now, we'll set up Novu and finally proceed to add both (Novu and FCM) to our app.

## Setting up Novu

We'll need a workflow to trigger notifications to our user's devices. Follow the steps below to create one to ensure we are on the path to make FCM work as expected:

1. Head over to the [Integrations Store](https://web.novu.co/integrations?utm_campaign=docs-guides-fcm-web) on the Novu Web Dashboard and make sure that you've turned on the 'Firebase Cloud Messaging' integration.

<Frame>
  <img />
</Frame>

<Info>If you're doing this for the first time, you'll need to get your service account key from the [Firebase Console](https://console.firebase.google.com/). Read more about it in our [FCM provider docs.](https://docs.novu.co/channels-and-providers/push/fcm)</Info>
2\. Now, we need to create a workflow that we'll trigger from our app to send notifications. Head over to [workflows in the Novu Web Dashboard](https://web.novu.co/workflows?utm_campaign=docs-guides-fcm-web) and click on the 'Add a workflow' button.

<Frame>
  <img />
</Frame>

3. Choose the 'blank workflow' option from the dropdown menu.

<Frame>
  <img />
</Frame>

3. Drag and drop the 'Push' node below the Workflow Trigger node.

<Frame>
  <img />
</Frame>

4. If you hover over the newly added 'Push' node, you'll see an error saying 'Message content and title are missing'.

<Frame>
  <img />
</Frame>

5. We're going to use the identifiers `title` and `body` for the title and the content of notifications, so let's add them in the 'Push message title' and the 'Push message content' fields respectively. So, add them and give your workflow a suitable name.

<Frame>
  <img />
</Frame>

6. Now, click on the 'get snippet' button to get the trigger code.

<Frame>
  <img />
</Frame>

## Adding Firebase to the frontend

1. In your project, add Firebase using the following command:

```bash theme={null}
npm install firebase
```

2. Create a new file called `firebase.js` and add the following to it:

```jsx theme={null}
import { initializeApp } from "firebase/app";
import { getMessaging, onMessage } from "firebase/messaging";

//from firebase console
// Your web app's Firebase configuration
const firebaseConfig = {
    apiKey: import.meta.env.VITE_FIREBASE_API_KEY,
    authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN,
    projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID,
    storageBucket: import.meta.env.VITE_FIREBASE_STORAGE_BUCKET,
    messagingSenderId: import.meta.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
    appId: import.meta.env.VITE_FIREBASE_APP_ID,
};

// Initialize Firebase
export const app = initializeApp(firebaseConfig);

// Initialize Firebase Cloud Messaging and get a reference to the service
export const messaging = getMessaging(app);

export const onMessageListener = () =>
    new Promise((resolve) => {
        onMessage(messaging, (payload) => {
            console.log("payload", payload)
            resolve(payload);
        });
    });
```

3. Now, we need to generate tokens using the `getToken` method provided by Firebase. But we want to use this only when the user has allowed notifications on their end. So let's request notification permission from the user and if granted, we'll generate the token. Add this to your root module:

```jsx theme={null}
 async function requestPermission() {
    const permission = await Notification.requestPermission()
    if (permission === 'granted') {
      // get token
      const token = await getToken(messaging, { vapidkey: import.meta.env.VITE_VAPID_KEY })
    } else if (permission === 'denied') {
      alert('Persmission denied!')
    }
  }
  useEffect(() => {
    requestPermission();
  }, [])
```

4. To use the `getToken` method, you need a Voluntary Application Server Identification or `VAPID key`. Go to your Project Settings -> Cloud Messaging -> Generate key pair (under Web Push Certificates):

<Frame>
  <img />
</Frame>

5. In order for Firebase's background listener service to work, you need a service worker. Make sure you've created a service worker file `firebase-messaging-sw.js` and add the following to it:

```jsx theme={null}
importScripts("https://www.gstatic.com/firebasejs/8.10.0/firebase-app.js");
importScripts(
    "https://www.gstatic.com/firebasejs/8.10.0/firebase-messaging.js"
);

const firebaseConfig = {
    apiKey: import.meta.env.VITE_FIREBASE_API_KEY,
    authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN,
    projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID,
    storageBucket: import.meta.env.VITE_FIREBASE_STORAGE_BUCKET,
    messagingSenderId: import.meta.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
    appId: import.meta.env.VITE_FIREBASE_APP_ID,
};

firebase.initializeApp(firebaseConfig);
const messaging = firebase.messaging();
messaging.onBackgroundMessage((payload) => {
    console.log(
        "notif incoming",
        payload
    );
    const notificationTitle = JSON.parse(JSON.parse(payload.notification)).title
    // payload.notification.title;
    const notificationOptions = {
        body: payload.notification.body,
        icon: payload.notification.image,
    };

    self.registration.showNotification(notificationTitle, notificationOptions);
});


```

## Adding Novu to the backend

In your app's backend, add Novu using the following command:

```bash theme={null}
npm install @novu/node
```

Now, create a route that you want to hit when called from the front end. In our app, this is the route:

```jsx theme={null}
import express from "express";
import { createNotif } from '../controller/notif.js'

const router = express.Router();

router.post('/create', createNotif)

export default router;
```

Now, we need a controller function to handle the logic for what is to be sent in the trigger function’s payload. In our case, this is the controller function:

```jsx theme={null}
import { inAppNotification } from "../novu/novu.js";

export const createNotif = async (req, res) => {

    const { title, body } = req.body
    try {
        await inAppNotification(title, body);
        res.status(201).json({ message: 'success', title: title, body: body });
    } catch (error) {
        res.status(409).json({ message: error.message });
    }
}
```

To make it modular, we’ll keep the trigger code in a separate function in a separate file (`novu.js`, in our case) and the trigger function is getting called in the controller function above by the name `createNotif`.

If you’re following the guide, you should already have the trigger function. But before we can add it to our app, we need one key thing - **Subscribers.**

[Subscribers](https://docs.novu.co/subscribers/subscribers) are entities to which the notifications are sent. You can see a list of subscribers in the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-guides-fcm-web) as well.

We'll create a subscriber in our app. Our backend will be written in Node.js, but we also have backend [SDKs in PHP, .NET, Go, Ruby, Python, and Kotlin](/sdks/introduction). The recommended way to create a subscriber in NodeJS is as follows:

```jsx theme={null}
 await novu.subscribers.identify(process.env.NOVU_SUB_ID, {
        firstName: "pushSubscriber"
    });
```

Here, we're creating a subscriber with the `subscriberID` of whatever value the `env` file contains for the identifier `NOVU_SUB_ID`. You can read more about subscribers [in our docs.](/subscribers/subscribers).

Back in our app, before we can now add the trigger function, we need to set device identifiers using the [setCredential method](https://docs.novu.co/channels-and-providers/push/fcm#set-device-token):

```jsx theme={null}
await novu.subscribers.setCredentials(process.env.NOVU_SUB_ID, PushProviderIdEnum.FCM, {
        deviceTokens: [process.env.DEVICE_TOKEN],
    });
```

<Info>You'll need to pass the `subscriberID` and the `deviceTokens` in the `setCredentials` method.</Info>

Finally, we can add the trigger code:

```jsx theme={null}
import { Novu, PushProviderIdEnum } from '@novu/node';

export const inAppNotification = async (title, body) => {

    const novu = new Novu(process.env.NOVU_API_KEY);
    await novu.subscribers.identify(process.env.NOVU_SUB_ID, {
        firstName: "pushSubscriber"
    });

    await novu.subscribers.setCredentials(process.env.NOVU_SUB_ID, PushProviderIdEnum.FCM, {
        deviceTokens: [process.env.DEVICE_TOKEN],
    });

    novu.trigger(process.env.NOVU_WORKFLOW_ID, {
        to: {
            subscriberId: process.env.NOVU_SUB_ID
        },
        payload: {
            title: title,
            body: body
        },
    });
};
```

We're done with the app. You can find the [frontend code](https://github.com/novuhq/fcmWebPushFE) as well as [backend code](https://github.com/novuhq/FCMWebPushBE) for the app on Github.

Congratulations on following the guide up until this point. If you’ve done everything as recommended, you’ll end up with an app that uses Firebase Cloud Messaging to send notifications to your users using Novu.


# How to use Novu to send notifications to a Slack channel
Source: https://v0.x-docs.novu.co/guides/slack-guide

Learn to send Slack notifications swiftly with Novu (manually managed)

# Introduction

In this guide, you'll learn how to use Novu to send notifications directly to a Slack channel. But before coding anything up, we first need to go through a setup process.
The corresponding docs for this guide are available on our [docs](https://docs.novu.co/channels-and-providers/chat/slack).
<Note>The entire code of this app (frontend as well as backend) can be found [here](https://github.com/novuhq/slack-app).</Note>

So let's begin!

# Create a Slack App

Creating a Slack app is fairly simple. Follow these steps to create your app:

1. Go to [Slack's app dashboard](https://api.slack.com/apps) and click on the 'Create new App' button, as shown in the image:

<Frame>
  <img />
</Frame>

2. Choose 'From Scratch' from the following dialog:

<Frame>
  <img />
</Frame>

3. Choose a name for your app and select the Slack workspace in which you want to send notifications:

<Frame>
  <img />
</Frame>

4. Once you're done, simply click the 'Create App' button:

<Frame>
  <img />
</Frame>

5. Once done, you'll be greeted with the screen shown below. We'll make a couple of changes here and it'll be ready to go.

<Frame>
  <img />
</Frame>

6. We'll need `Client Id` from the [Slack Developer's Dashboard](https://api.slack.com/apps) for configuring Slack Integration in the [Novu Web Dashboard](https://web.novu.co/integrations?utm_campaign=docs-guides-slack) later, so keep it handy.

<Frame>
  <img />
</Frame>

# Create a workflow in the Novu Web Dashboard

1. To create a workflow, head to the workflow section in the [Novu Web Dashboard](https://web.novu.co/workflows?utm_campaign=docs-guides-slack).
2. Click on the 'Add a workflow' button and select 'Blank workflow' from the dropdown.

<Frame>
  <img />
</Frame>

3. Once there, give your workflow a name and drag and drop the 'chat' option below the 'workflow trigger' step.

<Frame>
  <img />
</Frame>

4. You can also add variables in the Workflow Editor. For example, here I've added 'chatMsg' as a variable as I'll be sending data using it.

<Frame>
  <img />
</Frame>

<Info>Whatever is placed inside double braces is a variable.</Info>
5\. Make sure that you've turned on the Slack integration in the [Integrations Store](https://web.novu.co/integrations?utm_campaign=docs-guides-slack).

<Frame>
  <img />
</Frame>

6. To turn the Slack integration on, you'll need `Client Id`. You should have it already but if you don't, you can obtain it from the [Slack Developer's Dashboard](https://api.slack.com/apps).

<Frame>
  <img />
</Frame>

7. Once you have it, you need to plug it into the respective field in the [Slack Integration Settings](https://web.novu.co/integrations?utm_campaign=docs-guides-slack) on the Novu Web Dashboard.

<Frame>
  <img />
</Frame>

# Create the backend

The backend for this app is quite simple. Simply install the Novu package:

```bash theme={null}
npm install @novu/node

```

Now, create a route that you'll hit when called from the front end. We'll also need to add it to our Slack app (discussed below). For our demo app, this is the route I've created:

```jsx theme={null}
import express from "express";
import { chatController } from "../controller/chat.js";

const router = express.Router();

router.post("/sendChat", chatController);

export default router;
```

Now, we need a controller function to handle what is to be sent in the trigger's function payload. Here's the controller I wrote:

```jsx theme={null}
import { chat } from "../novu/novu.js"

export const chatController = async (req, res) => {
    const { chatMsg } = req.body;
    try {
        await chat(chatMsg);
        res.status(201).json({ message: "Message sent successfully" });
    } catch (error) {
        res.status(500).json({ message: error.message })
    }
}
```

<Info>Notice how we're expecting 'chatMsg' in our payload. This is why we added it as a variable in the workflow created earlier.</Info>

To make it modular, we’ll keep the trigger code in a separate function in a separate file, `novu.js`, in our case, which is as follows:

```jsx theme={null}
import { Novu, ChatProviderIdEnum } from '@novu/node';

export const chat = async (chatMsg) => {
    const novu = new Novu(process.env.YOUR_NOVU_API_KEY_HERE);
    await novu.subscribers.identify(process.env.SUB_ID, {
        firstName: 'newSubForSlackChat',
    });

    await novu.trigger('slack', {
        to: {
            subscriberId: process.env.SUB_ID
        },
        payload: {
            chatMsg: chatMsg
        }
    });
}
```

In this code snippet above, we're first initializing a new instance of Novu, then using it to 'identify' or [create](https://docs.novu.co/subscribers/subscribers#create-a-subscriber) a [subscriber](https://docs.novu.co/subscribers/subscribers).
<Info>The 'identify' method tries to find a subscriber with the given info. If it can't find any such subscriber, it creates a new subscriber with the supplied info.</Info>
After creating the subscriber, it runs the trigger code for the workflow we had created. You can find the trigger workflow by clicking on the 'Get Snippet' button on the workflow:

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

# Configure the Slack app

There are two ways to configure the Slack app. One is the Novu managed option and another the manually managed option.
Since the Novu managed is fairly straightforward, I'll demonstrate the manual method here. Follow along to set it up!

1. Goto 'Incoming Webhooks' in your Slack app settings and turn it on.

<Frame>
  <img />
</Frame>

2. Click on the 'Add New Webhook to Workspace':

<Frame>
  <img />
</Frame>

3. Now, go ahead and select the channel in which you want to send notifications and click 'allow'.

<Frame>
  <img />
</Frame>

4. Then, copy the 'webhookUrl' from Slack.

<Frame>
  <img />
</Frame>

5. Now, add the code below to the backend trigger functionality. Using this code, we are specifying what `webhookUrl` Novu will use to authenticate when using the Slack provider.

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Slack, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "slack",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "slack-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

In our case, we'll add it to the `Novu.js` file we created earlier so that the final file becomes :

```jsx theme={null}
import { Novu, ChatProviderIdEnum } from '@novu/node';

export const chat = async (chatMsg) => {
    const novu = new Novu(process.env.YOUR_NOVU_API_KEY_HERE);
    await novu.subscribers.identify(process.env.SUB_ID, {
        firstName: 'newSubForSlackChat',
    });

    await novu.subscribers.setCredentials(process.env.SUB_ID, ChatProviderIdEnum.Slack, {
        webhookUrl: process.env.SLACK_WEBHOOK_URL,
    });

    await novu.trigger('slack', {
        to: {
            subscriberId: process.env.SUB_ID
        },
        payload: {
            chatMsg: chatMsg
        }
    });
}
```

6. Finally, we'll add the route we'd created earlier to the redirect URL section, as shown:

<Frame>
  <img />
</Frame>

<Info>For demonstration purposes, I've added both the local as well as the deployed URL. You only need one depending on whether you're running this locally or have a deployed version.</Info>
Now, our backend is all done, our Slack is all setup and all we need to do is hit the URL

# Front end set up

For our demonstration purposes, the front end is pretty basic. All we have to do is have an input field to take the notification text in and send the payload. The front end code for this demo app is available on our [Github repo](https://github.com/novuhq/slack-app/tree/main/frontend).
And here's our app in all its glory!

<Frame>
  <img />
</Frame>

This is how we send Slack notifications using Novu!


# Centralized multiple legacy implementations of different teams
Source: https://v0.x-docs.novu.co/guides/usecases/centralized-multiple-legacy-implementations

Learn to use Novu to centralize legacy notification implementations.

If you're coming from a medium or large team with multiple implementations of sending notifications across channels, then you can be rest assured that Novu will be the central gateway.

* Install Novu's SDK (according to your preferred tech).
* Connect your existing delivery providers to Novu.
* [Migrate your users to subscribers](/subscribers/subscribers#import-subscribers) on Novu either via Cloud or on-prem.
* Now, every notification fires via Novu.

Teams in charge of content can always update the workflow templates via the dashboard. Engineers can always debug and add as many providers or activate as many more channels needed!


# Debug notifications across channels in a single place
Source: https://v0.x-docs.novu.co/guides/usecases/debug-notifications

Understand the lifecycle of your notifications

Debugging notifications can be a hassle. Novu allows you understand and debug notifications sent across different channels in one place.

In [Novu's Activity Feed](https://web.novu.co/activities?utm_campaign=docs-usecases-debug), you can access a log of all the notifications that have been sent & filter through the successful & failed ones. Furthermore, you'll know why it failed!

You can filter through channels, workflows, emails, subscribers and transactions.

<Frame>
  <img />
</Frame>

<br />

<Frame>
  <img />
</Frame>

[Explore more about Novu’s Activity Feed](/activity-feed/introduction)


# Digest multiple events in a single notification
Source: https://v0.x-docs.novu.co/guides/usecases/digest-multiple-events

Learn to leverage Novu in digesting multiple events.

One of the recurring features developers yearn for is the ability to batch multiple notifications and send as one to subscribers.

Novu ships with a built-in digest engine that handles batching and digesting multiple events in a single notification. You can programmatically adjust the digest recurrence or set it from the dashboard.

<Frame>
  <img />
</Frame>

[Explore more about Novu's Digest Feature](/workflows/digest)


# Fully featured embedded notification center
Source: https://v0.x-docs.novu.co/guides/usecases/embedded-notification-center

A real-time fully functional embedded notification center

Novu provides a real-time embedded notification center widget that can simply be dropped into any web application.

<Frame>
  <img />
</Frame>

It's available as a drop-in component for React, Vue and Angular apps. For non-specific frameworks, it's also ready as a bundled web component.

We care about the developer experience so much that we also built a headless, zero-UI version to empower you to hand-craft your notification center.

[Explore a lot more about the Notification Center here](/notification-center/introduction)


# Learn by usecase
Source: https://v0.x-docs.novu.co/guides/usecases/introduction

Learn Novu's Use Cases

Novu is built to empower engineering teams in integrating rich product notification experiences seamlessly without re-inventing the wheel.

It has been thoroughly and beautifully crafted to help individuals, teams, businesses and organizations focus on what truly matters: creating exceptional user experiences and driving engagement through smooth and swift notifications delivery.

The common use cases for using Novu are highlighted below:

<CardGroup>
  <Card title="Managing multiple delivery providers in one place" icon="circle-1" href="/use-cases/multiple-delivery-providers" />

  <Card title="Fully featured embedded Notification Center" icon="circle-2" href="/use-cases/embedded-notification-center" />

  <Card title="Digest multiple events in a single notification" icon="circle-3" href="/use-cases/digest-multiple-events" />

  <Card title="Manage notification in multiple languages" icon="circle-4" href="/use-cases/manage-notifications-in-multiple-languages" />

  <Card title="Processing and sending notifications at any scale" icon="circle-5" href="/use-cases/send-notifications-at-any-scale" />

  <Card title="Centralized multiple legacy implementations of different teams" icon="circle-6" href="/use-cases/centralized-multiple-legacy-implementations" />

  <Card title="Debug notifications across channels and vendors in a singe place" icon="circle-7" href="/use-cases/debug-notifications" />
</CardGroup>


# Manage notifications in multiple languages
Source: https://v0.x-docs.novu.co/guides/usecases/manage-notifications-in-multiple-languages

Learn to send notifications in different languages effortlessly

This feature is currently under development. However if you urgently need this, [reach out to us for more information](https://notify.novu.co/meetings/novuhq/notifications-45min?utm_campaign=novuDocs\&utm_content=notifications-in-multiple-languages-docs).


# Managing multiple delivery providers in one place
Source: https://v0.x-docs.novu.co/guides/usecases/multiple-delivery-providers

Learn to manage many delivery providers across different channels in one dashboard

[Novu's dashboard](https://web.novu.co/integrations?utm_campaign=docs-usecases-multipledelivery) empowers you to manage all your notification delivery providers across Email, Sms, Push and Chat in one place.

You can activate, deactivate, modify settings, set primary and secondary active providers as you wish from the dashboard.

### Integrations Store

<Frame>
  <img />
</Frame>

### Add a new Delivery Provider

<Frame>
  <img />
</Frame>


# Processing and sending notifications at any scale
Source: https://v0.x-docs.novu.co/guides/usecases/send-notifications-at-any-scale

Novu can handle notifications at extremely large scale

[Novu's Cloud](https://web.novu.co?utm_campaign=docs-usecases-notificationsscale) is built to process and send notifications at any scale. For folks using the self-hosted Novu version, you can scale it up as your needs grow.

If you're looking to use Novu on a very large scale & you need to confirm infrastructure & scalability prowess, [please reach out to us for more information](https://notify.novu.co/meetings/novuhq/notifications-45min?utm_campaign=docs-bam-usecases-notificationsscale).


# Account Management
Source: https://v0.x-docs.novu.co/help/account-management



### Creating an account

Novu supports [US](https://web.novu.co/auth/signup?utm_campaign=docs-gs-help-account-mgmt) and [EU](https://eu.web.novu.co/auth/signup?utm_campaign=docs-gs-help-account-mgmt) regions based on where you want your data to be stored. In both the regions, a new account can be created using Github or Email and Password. If you are looking for other ways to signup on Novu, feel free to reach out us at [support@novu.co](mailto:support@novu.co).

### Resetting password

If you have created an account with Novu before, you can reset your password by clicking on `Forgot Your Password?` option on the sign-in page.

### Is US and EU account data synced?

US and EU accounts are completely independent. If you have created an account in the US, you will not be able to login with the same credentials in the EU and vice versa.

### Changing the email associated to my account

If you want to change your account email, please reach out to us at [support@novu.co](mailto:support@novu.co).

### What happens if I change my Github account email?

If you created your Novu account using Github, and you change your email in Github, it will not be reflected in Novu. When you login to Novu using the new Github email, a new account will be created. Please email [support@novu.co](mailto:support@novu.co) to update your email address.

### How do I create a new Organization?

A new organization can be created by writing something in the dropdown in the left bottom corner of the dashboard. As soon you start writing something, an add option will apear. This dropdown can also be used to switch between [organizations](/getting-started/concepts#organization). One organization's data is not visible to other organization members.

### How to change organization name?

We are working on account management feature currently so this option is not available in UI as of now. If you want to change your current organization name, [rename organization api](/api-reference/organizations/rename-organization) can be used. if you face any issue in using api or need any help any changing the organization name, please reach out to us at [support@novu.co](mailto:support@novu.co).

### How to upload multiple image assets similar to logo?

Currently, Novu supports uploading only one logo image per organization. If you want to use other images in workflow step content then a valid absolute url of image can be used with `<img>` tag.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Chat
Source: https://v0.x-docs.novu.co/help/channels/chat



### Can I send a message to a specific user on Slack?

While installing the Slack app, you will be asked the User or Channel to which the message needs to be sent. On selecting a user, a webhookUrl for that user will be generated and Novu will use that webhookUrl to send a message to that specific user.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Email
Source: https://v0.x-docs.novu.co/help/channels/email



### How to override default values of Email?

All values (from, to, subject, body, etc.) can be overridden by using the `overrides` option while triggering the workflow. Please see our [email overrides documentation](/channels-and-providers/email/overview#sending-email-overrides) for more details.

### Sending HTML as the value of a variable

HTML content as a value of step variable can be sent by replacing the double curly braces `{{}}` variable with triple curly braces `{{{}}}` variable. For example, `{{{htmlContent}}}`.

### I have multiple Email Providers or integrations active, how do I associate them to a Workflow?

There can be more than one active email integrations of same or different providers. However only one email integration can be primary at one time per environment. To use a different email integration than your primary integration, the integrationIdentifier field of email overrides can be used. Read about using [different email integration](/channels-and-providers/email/overview#using-different-email-integration) for more details.

### Why am I getting the error “message content could not be generated”?

This error occurs when the HTML content is not properly formatted. Make sure the HTML content is properly formatted and does not contain any syntax errors. Make sure Step Variables are properly formatted and are not missing opening or closing curly braces.

### Can email or phone be used as step variables?

Novu recommends not to use subscriber attributes as step variables. Instead, use the subscriber attributes directly in the step. For example, use `{{subscriber.email}}` instead of `{{email}}` as your step variable. Novu will select the email from subscriber attributes and inject the value in the content.

### How to use Provider templates in place of email content?

Currently, we support external Provider template support for [sendgrid](/channels-and-providers/email/sendgrid#using-sendgrid-template) and [mailersend](/channels-and-providers/email/mailersend#using-mailersend-template) only.

### Can I retrieve only Email content?

Novu does not have a separate API to retrieve email content. However, email content can be retrieved from the email step of the workflow. The email step contains the email content in the `content` field of [get worklfow api](/api-reference/workflows/get-workflow) response.

### How to send inline images in email?

Inline images can be sent using `<img>` tag in the email content. PNG, JPEG, GIF are supported. SVGs are not supported as inline images by most of email clients like gmail, outlook.

### How to add unsubscribe link in emails?

Add `{{unsubscribe}}` variable in email step content editor and send url value of this variable in payload. Create a simple html page to [fetch preferences](https://docs.novu.co/api-reference/subscribers/get-subscriber-preferences) and then use [update preference api](https://docs.novu.co/api-reference/subscribers/update-subscriber-preference) to update.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# In App
Source: https://v0.x-docs.novu.co/help/channels/in-app



### Creating two In-App Notification Centers in one account

To configure your In-App notifications, you must use the In-App integration from our integration store.

To display in-app notifications to users, any SDKs in our [client library](/notification-center/introduction) can be used. Every library requires `applicationIdentifier` and `subscriberId` to fetch notifications. Currently, only one `applicationIdentifier` is supported per environment per organization.

Feel free to reach out to us at [support@novu.co](mailto:support@novu.co) if you have speicific requirements of multiple `applicationIdentifier` per organization.

### Issues with a redirect URL

To redirect to specified redirect url on clicking the in-app notification, notification click event should be handled in client side code. Here is an example in [React](/notification-center/client/react/get-started#onnotificationclick).

### Changing the default colors of the Notification Center

Styling of your In-App Notification Center can be customized using the [styles](/notification-center/client/react/customization#customization-using-styles-prop) prop. If you want to customize only a single component, you can use [available](/notification-center/client/react/customization#popovernotificationcenter-customization) props.

### Additional Security for In-App Notifications

To add an extra layer of security, we recommend using our HMAC encryption feature to eliminate subscriber impersonation Checkout [HMAC](/notification-center/client/react/get-started#hmac-encryption) section for more details.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Push
Source: https://v0.x-docs.novu.co/help/channels/push



### Can I send a Desktop Push notification?

Yes, Desktop Push Notifications can be sent by using a Web Push Notification. It is supported with almost all [push channel](/channels-and-providers/push/overview) providers.

### Why am I getting the error “unexpected provider” with FCM?

The possible reasons for this error are:

* Invalid FCM credentials.
* Invalid or stale FCM token.

### Why am I getting the error “Sending message failed due to Requested entity was not found” with FCM?

* This error occurs when the FCM token is invalid or stale. You can fix this by updating the FCM device token.

### Can I store device tokens for particular FCM integration if I have multiple FCM providers active?

* Device tokens for particular FCM integration can be stored using the `integrationIdentifier` field of [update subscriber credentials api](/api-reference/subscribers/update-subscriber-credentials). `integrationIdentifier` is the unique identifier of the integration which is similar to `providerIdentifier`. It can be copied from the integration form.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# SMS
Source: https://v0.x-docs.novu.co/help/channels/sms



### Why am I getting the error “ subscriber does not have a configured channel”?

This error occurs when a Subscriber is missing `phone` attribute. To fix this error, you need to update the subscriber and set the `phone` attribute with a valid phone number.

### How to change the default sender name for SMS?

First, ensure a custom sendername (sender id or from) is allowed with your Provider. Some countries expect to verify the sender name before using it.

You can change the default sender name for SMS by using [overrides](/channels-and-providers/sms/overview#sending-sms-overrides) field while triggering the workflow.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Content Management
Source: https://v0.x-docs.novu.co/help/content-management



### What is a Layout and how can I use them?

Layout is similar to a style container for email templates. Layouts can be used for your organization’s branding and style. It can be used to define the structure of the email template such as the header, footer, and other common elements. It must have a `{{{body}}}` variable which will be replaced by the actual email template content.

### Can Layouts be used across all channels?

Layouts are specific to Emails.

### Can MJML templates be used in content editors?

Only HTML templates can be used in content editors. We support [handlebar helpers](/content-creation-design/handlebars-helpers) for common use cases like iteration, conditions etc. If you need any specific Handlebar Helpers, please reach out to us at [support@novu.co](mailto:support@novu.co).

### Can the content of one Step be used in another?

Currently each Step has content that is unique to it and can not be reused. If this is important to you, please send us a note at [support@novu.co](mailto:support@novu.co).

### Which Translation Language will be used if the Subscriber’s locale field does not match with translation language files?

If the Subscriber's locale field does not match with Translation locale files, or it is not available, then the defaul language of the translation group will be used. If a default is not set, the automatic fallback is English.

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Frequently Asked Questions
Source: https://v0.x-docs.novu.co/help/faq



## Platform

### What is an event?

An event is every call to our [trigger API](https://docs.novu.co/api-reference/events/trigger-event/?utm_campaign=docs-faq) or digested with other notifications into any call can be converted through the Novu logic engine into many different notifications or digested with other ones into one notification. In case a trigger was used for many subscribers at once, it will be calculated per unique subscriber. In case many events are converted into one notification they will be calculated at a lower rate.

### What is a notification?

A notification is any message sent over any channel, after the Novu logic engine, Novu user preferences, and your configuration calculated and crafted the message. A notification can be sent to an email, In-App notification center, chat, push, and more.

### What is the difference between seen and read in the context of notifications?

An in-app notification (message) is marked as seen when you open the notification center and that notification(message) is visible
whereas it is marked as read either by clicking on that notification (message) or clicking the 'Mark as Read' option.

### I want to send millions of events, but only send thousands of notifications, can I?

Sure thing! This can easily be done using Novu’s digest + delay, features allowing for ingesting many events into well crafted must have messages over all channels.

### What are the differences between Novu Cloud and Open Source?

Novu [Open source](https://github.com/novuhq/novu) is a technology available under an MIT license, built and maintained by the Novu community, you can adapt it to your needs, contribute, or simply use docker files and run it. Novu Cloud is a managed service run, managed, and maintained by Novu Cloud version is scalable and robust by design, and uptime SLAs, and includes more business-facing features, that are not available under the Open Source version.

### Can I send more than 1 million events a month on Novu Cloud?

Yes, you absolutely can. Our managed cloud system was built to scale with your usage, so you don’t have to worry about it.

### I need some help configuring Novu, where can I find it?

No worries, we got your back. Many questions can be answered on our [documentation site](https://docs.novu.co/?utm_campaign=docs-faq). If for some reason something is missing, go ahead and use our [Discord](https://discord.gg/novu?ref=docs-faqs), we usually answer right away, and with the help of the community members and moderators, it’s very effective.

### What are the differences between Discord and Intercom support?

We have two main public support channels, Discord and Intercom. Discord is our community support channel supporting anything between self-hosted issues, bugs, code contributions, general discussions, feature requests, Novu-Cloud questions, and don’t forget memes :) On our Intercom support, we focus on Novu-Cloud questions, and ensure we can provide the best support based on our knowledge of Cloud usage.

### Where can I find the roadmap?

Glad you want to see what’s next, check out our roadmap [here](https://roadmap.novu.co/roadmap). Feel free to suggest other things and upvote features and requests.

### Does the Novu In-App notification center work with Angular, Vue, and React?

Yes, it does, The Novu In-App notification center is built using pure HTML components, and wrapped in your most beloved frameworks wrapper to provide a nice and consistent developer experience.

### Do you offer any enterprise plan?

Yes, we do. Enterprise plans are available for teams who require extended enterprise-grade features, and specific SLAs or have unique concerns about PII, security, insurance, or legal. Feel free to reach out to us over Intercom, or go to [contact us](https://novu.co/contact-us/?utm_campaign=docs-faq).

### Do you have offer enterprise support plan?

As part of our enterprise support, you’ll get our usual support channels as well as a Microsoft Teams/Slack/Discord channel. In case you want to add an enterprise support plan, with dedicated technical support, we are happy to offer that next to an active enterprise plan.

### I need more events or enterprise features, can you help?

We sure can. We are happy to work with enterprises and build Novu to support both their needs as well as the grand community ones. From new features, security, and privacy, or if you need to send dozens or hundreds of events a month, we are here to help. Feel free to reach out to us over Chat, or [contact us](https://novu.co/contact-us/?utm_campaign=docs-faq).

### Can I see some examples of how to use Novu?

Code examples can be found on our [Github Repo](https://github.com/novuhq/examples), and [our documentation](https://docs.novu.co/getting-started/your-first-notification?utm_campaign=docs-faq). We have examples for common use cases like sending notifications from a web server, mobile app, or integrating with other services.

### I am missing a channel provider, can I ask for one? Or add it myself?

You sure can, if you just want to ask for a new one, the easiest way is to go to our [Github issues](https://github.com/novuhq/novu/issues), and ask for a [new one](https://github.com/novuhq/novu/issues/new?assignees=\&labels=feature\&template=feature_request.yml\&title=%F0%9F%9A%80+Feature%3A+), just make sure if there is another request you upvote it instead of creating a new one. If you are willing to contribute a provider just go to [how to contribute one](https://docs.novu.co/community/add-a-new-provider?utm_campaign=docs-faq) on our docs, thank you!

### Do you have a status page?

Yes we do, check it out [here](https://novustatus.com/).

### I started using Novu Open Source, and I want to move to Novu Cloud, is there any migration tool?

We are now building an automatic tool to help with this migration process, for now, feel free to ask us over Discord, or at [engineering@novu.co](mailto:engineering@novu.co).

## Pricing

### Can I use Novu free of charge?

Yes, you can. If you send less than 30K events per month, then Novu Cloud is entirely free. Another option is to deploy the Open-Source version of Novu onto your own infrastructure, but that does not give you the unique SLA and global redundancy we have in the Cloud version of Novu.

### What is the pricing?

Pricing page is available [here](https://novu.co/pricing/?utm_campaign=docs-faq).

### If I am sending millions of events, but thousands of notifications, will this affect the price?

That’s a great way to do it, sending many events and only handful of notifications means you are able to convey a lot of value while keeping your subscribers happy. We are not only supporting it, it’s also affecting price. On high-volume events to notification, where digest is heavily used each event is calculated as 1/10 of the normal usage.


# Observability
Source: https://v0.x-docs.novu.co/help/observability

Analyzing your Triggered Events and Notification execution logs

### My Subscribers have preferences set, but the Activity Feed is showing Triggers as being sent.

The Activity Feed is a place each event (Workflow Trigger) is listed. If a Subscriber has a preference to not receive notifications through a certain channel, Novu’s system will adhere to that. However, this is still a valid Trigger as the fanout occurs before preferences are accommodated.

### What does "step filtered by subscriber preferences" mean in the logs?

It means that the Subscriber has set preferences configured and the step was filtered based on that preference. If the subscriber has disabled a step Channel then, the step will be filtered and notification will not be sent to the subscriber.

### How to export Activity Feed data?

Currently, we don't have any option to export activity feed data. But you can use our [API](/api-reference/notification/get-notifications) to fetch the data. If there is a specific system you’re looking to integrate with, please send us a note at [support@novu.co](mailto:support@novu.co).

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Orchestration
Source: https://v0.x-docs.novu.co/help/orchestration



## Digest

### New event triggers are merging an active Digest with an old duration..

When a Digest is created with a set duration and an event is triggered, the Digest stays active ( and will batch the events) until the configured duration is over.

If you change the duration before the initial time period has completed , the previous digest will still be active and the new duration is merged with the old duration Digest until the previous duration is complete.

To remove the previous Digest, use [event cancel api](/api-reference/events/cancel-triggered-event) to cancel all event triggers that are still pending and are merged in active Digests.

### Can I dynamically make the Digest inactive??

Yes, Digest supports conditions and can be applied to your Digest step. If the Triggered Event passes the set conditions, then it will be active or inactive based on the condition.

### Can a Subscriber control the Digest duration and time?

Not currently. The Digest duration  can be changed at the Workflow level only and is applied to all subscribers that Workflow is triggered to. If you have an identified use case for this, please let us know at [support@novu.co](mailto:support@novu.co).

## Delay

### What happens if the delay scheduled date and time is in the past?

If the delay scheduled date and time is in the past, the delay step will fail. Based on the step configuration, workflow will either continue to the next step or workflow will be failed

<Info>
  If your question is not answered here, feel free to reach out us at [support@novu.co](mailto:support@novu.co)
</Info>


# Others
Source: https://v0.x-docs.novu.co/help/others



### Workkflows changes are not showing on the changes

If some changes are pending to promote for the same workflow, then Novu merges subsequent changes into the existing change item.

### Getting CORS error with the API

Novu APIs are developed to be used on the server side. If you are using the API from the browser, you will get a CORS error. You can use the API from the server side or checkout our [client-side libraries](/notification-center/introduction) to fetch in-app notifications.


# Help Center Overview
Source: https://v0.x-docs.novu.co/help/overview

Introduction to Novu help center

At our Help Center, we're dedicated to provide comprehensive support to ensure your experience with our products and services is seamless and enjoyable. Whether you're a new user looking for guidance or a seasoned customer seeking assistance, we're here to help. Help Center is organized as per our product architecture and is divided into the following sections:

<CardGroup>
  <Card title="Account Management" href="/help/account-management" icon="user">
    Manage your account and access your data.
  </Card>

  <Card title="User Management" href="/help/user-management" icon="users">
    Manage subscribers and topics
  </Card>

  <Card title="Channels" href="/help/channels" icon="bars">
    Explore all channels and how to use each one.
  </Card>

  <Card title="Orchestration" href="/help/orchestration" icon="screwdriver-wrench">
    Explore orchestration digest, delay, conditions and more.
  </Card>

  <Card title="Content Management" href="/help/content-management" icon="file-pen">
    Content management, layouts, templates, and more.
  </Card>

  <Card title="Observability" href="/help/observability" icon="magnifying-glass">
    Observability, metrics, analytics, and more.
  </Card>

  <Card title="Others" href="/help/Others" icon="crystal-ball">
    Others help topics.
  </Card>

  <Card title="FAQs" href="/help/faq" icon="comment">
    Read frequently asked questions
  </Card>
</CardGroup>

<Frame>
  <img />
</Frame>


# User Management
Source: https://v0.x-docs.novu.co/help/user-management



## Subscribers

### What is a Subscriber?

A subscriber is an entity to which notifications are sent. It is a Novu term similar to a user in your system. As in your system, a user is identified by a unique id, similarly in Novu, a subscriber is identified by a unique id called `subscriberId`. We recommend that the existing value you use in your system as a `userId` to be used as `subscriberId` in Novu. Read more about subscribers on [subscribers documentation page](/subscribers/subscribers).

### Is it necessary to use subscriberId as same as userId?

No, it is not necessary to use subscriberId as same as userId. You can use any unique id as subscriberId. We recommend using userId as subscriberId to avoid any confusion. Some of our customers use a pattern like `auth0|userId` as a value for `subscriberId`.

### Can notification be sent without adding a Subscriber?

No, a notification cannot be sent without adding a subscriber. A subscriber is an entity to which notifications are sent. You need to add a subscriber to Novu before triggering the workflow or inline of trigger. Read more about subscribers on [subscribers documentation page](/subscribers/subscribers).

### What is the right approach to add Subscribers?

Subscribers can be added either [ahead of trigger](/subscribers/subscribers#1-ahead-of-trigger) or [inline of trigger](/subscribers/subscribers#2-inline-of-trigger). One way to add a subscriber using inline of trigger is to create  a new subscriber in Novu as soon as they sign up or register in your system.

You can add your existing users as subscribers in Novu using [bulk create subscriber creation method](/subscribers/subscribers#bulk-subscriber-creation).

### Can Subscriber credentials be added while creating a new Subscriber?

Subscriber credentials for Push and Chat channel providers cannot be added while creating a new subscriber. Subscriber credentials for Push and Chat channel providers can be added using the [update subscriber credentials api](/api-reference/subscribers/update-subscriber-credentials) or corresponding sdk methods.

SMS and Email channels are a bit different because all providers can work with the same value, so `email` and `phone` [attributes](/subscribers/subscribers#subscriber-attributes) can be added while creating a new Subscriber.

### Can Subscriber preferences be updated while adding a new Subscriber?

Subscriber preference cannot be updated while adding a new subscriber. Novu sets all channels as true by default for new subscribers. You can modify preferences at any time. Read more about [subscriber preferences](/subscribers/preferences).

### Can two subscribers with different `subscriberId`s have the same email address?

Yes, it is possible for two subscribers to have the same email address in our system. This is because the `subscriberId` is the unique identifier that distinguishes one subscriber from another. Even if two subscribers share the same email address, they will have different `subscriberId`s, which allows our system to identify and manage them separately.

## Topics

### Can a Subscriber be added to multiple topics at once?

Currently, Novu supports adding a subscriber to only one topic at a time. You can add a subscriber to multiple topics by calling the [add subscriber to topic api](/api-reference/topics/subscribers-addition) multiple times with a particular topic key


# Angular Component Library
Source: https://v0.x-docs.novu.co/sdks/angular

Novu’s Angular library provides an Angular component wrapper over the Notification Center Web that you can use to integrate the notification center into your Angular application. 

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/notification-center-angular)

## Installation

```javascript theme={null}
npm install @novu/notification-center-angular
```

<Tip> If you're ready to start integrating in your Angular app, jump straight to our [Angular quickstart](/quickstarts/angular)</Tip>

Learn more about usage of the [Angular Component in detail.](/notification-center/client/angular)


# C#/.NET
Source: https://v0.x-docs.novu.co/sdks/dotnet

Connect a .NET application to Novu

Novu's .NET SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your C#/.NET application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-dotnet)

## Installation

```dotnet theme={null}
dotnet add package Novu
```

<Tip>
   If you're ready to start integrating in your .NET app, jump straight to
  our [.NET quickstart.](/quickstarts/.NET)
</Tip>

## Usage

```dotnet theme={null}
using Novu.DTO;
using Novu.Models;
using Novu;
...

var novuConfiguration = new NovuClientConfiguration
{
    // Defaults to https://api.novu.co/v1
    Url = "https://novu-api.my-domain.com/v1",
    ApiKey = "12345",
};

var novu = new NovuClient(novuConfiguration);

// OnboardEventPayload.cs
public class OnboardEventPayload
{
  [JsonProperty("username")]
  public string Username { get; set; }

  [JsonProperty("welcomeMessage")]
  public string WelcomeMessage { get; set; }
}

// MyFile.cs
var onboardingMessage = new OnboardEventPayload
{
  Username = "jdoe",
  WelcomeMessage = "Welcome to novu-dotnet"
};

var payload = new EventTriggerDataDto()
{
  EventName = "onboarding",
  To = { SubscriberId = "subscriberId" },
  Payload = onboardingMessage
};

var trigger = await novu.Event.Trigger(payload);

if (trigger.TriggerResponsePayloadDto.Acknowledged)
{
  Console.WriteLine("Trigger has been created.");
}
```


# Go SDK
Source: https://v0.x-docs.novu.co/sdks/go

Connect a Go application to Novu

Novu's Go SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Go application.

[Explore the source code on GitHub](https://github.com/novuhq/go-novu)

## Installation

```go theme={null}
go get github.com/novuhq/go-novu
```

<Tip> If you're ready to start integrating in your Go app, jump straight to our [Go quickstart.](/quickstarts/go)</Tip>

## Usage

```go theme={null}
package main

import (
	"context"
	"fmt"
	novu "github.com/novuhq/go-novu/lib"
	"log"
)

func main() {
	subscriberID := "<REPLACE_WITH_YOUR_SUBSCRIBER>"
	apiKey := "<REPLACE_WITH_YOUR_API_KEY>"
	eventId := "<REPLACE_WITH_YOUR_EVENT_ID>"

	ctx := context.Background()
	to := map[string]interface{}{
		"lastName":     "Doe",
		"firstName":    "John",
		"subscriberId": subscriberID,
		"email":        "john@doemail.com",
	}

	payload := map[string]interface{}{
		"name": "Hello World",
		"organization": map[string]interface{}{
			"logo": "https://happycorp.com/logo.png",
		},
	}

	data := novu.ITriggerPayloadOptions{To: to, Payload: payload}
	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

	resp, err := novuClient.EventApi.Trigger(ctx, eventId, data)
	if err != nil {
		log.Fatal("novu error", err.Error())
		return
	}

	fmt.Println(resp)

	// get integrations
	integrations, err := novuClient.IntegrationsApi.GetAll(ctx)
	if err != nil {
		log.Fatal("Get all integrations error: ", err.Error())
	}
	fmt.Println(integrations)
}
```


# Headless JavaScript Service
Source: https://v0.x-docs.novu.co/sdks/headless-javascript-service

Novu’s headless library provides users with a lightweight, completely unstyled, zero UI solution for integrating notification functionality into their web applications.

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/headless)

With just the essential API methods, users can easily incorporate our notification system into any framework or vanilla JavaScript project, without being constrained by our default UI or dependencies.

<Tip>
  If you're ready to start using the Headless Notification Center, check out our [guide!](/guides/headless-notification-center-guide)
</Tip>

Learn more about usage of the [Headless Services in detail.](/notification-center/client/headless/get-started)


# Iframe Embed Notification Center
Source: https://v0.x-docs.novu.co/sdks/iframe-embed

Embed a real-time notification center inside an iframe using our embedded script.

If you are using a (currently) unsupported client framework, you can use our embedded script.

Learn more about usage of the [Iframe Embed in detail.](/notification-center/client/iframe)


# SDKs & Client Libraries
Source: https://v0.x-docs.novu.co/sdks/introduction

You can interface with Novu's API either over REST, or via libraries for certain languages. Below is a list of our official, supported libraries.

<Note>It's important to note that our API and backend SDK are intended for use exclusively in server-side applications.
**Attempting to use them in a client-side application will result in Cross-Origin Resource Sharing (CORS) errors.**
This restriction ensures the security and integrity of our services.</Note>

## Client Side

The Client side libraries and components helps to add a fully functional notification center to your application.

<CardGroup>
  <Card title="Vue" icon="vuejs" href="/sdks/vue">
    Embed a real-time notification center component in your Vue application.
  </Card>

  <Card title="React" icon="react" href="/sdks/react">
    Embed a real-time notification center component in your React application.
  </Card>

  <Card title="Angular" icon="angular" href="/sdks/angular">
    Embed a real-time notification center component in your Angular application.
  </Card>

  <Card title="Web Component" icon="square-js" href="/sdks/web-component">
    Embed a real-time notification center component in your JavaScript
    application.
  </Card>

  <Card title="IFrame Embed" icon="html5" href="/sdks/iframe-embed">
    Embed a real-time notification center inside an iframe using our embedded
    script.
  </Card>

  <Card title="Headless JavaScript" icon="js" href="/sdks/headless-javascript-service">
    Embed a notification system into any framework or vanilla JavaScript
    project, without being constrained by our default UI or dependencies.
  </Card>
</CardGroup>

## Server Side

The Server side libraries helps to trigger notifications and interact with all of Novu’s API seamlessly.

<CardGroup>
  <Card
    title="Node.js"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="21.47" viewBox="0 0 512 314"><defs><linearGradient id="logosNodejs0" x1="68.188%" x2="27.823%" y1="17.487%" y2="89.755%"><stop offset="0%" stopColor="#41873F"/><stop offset="32.88%" stopColor="#418B3D"/><stop offset="63.52%" stopColor="#419637"/><stop offset="93.19%" stopColor="#3FA92D"/><stop offset="100%" stopColor="#3FAE2A"/></linearGradient><linearGradient id="logosNodejs1" x1="43.277%" x2="159.245%" y1="55.169%" y2="-18.306%"><stop offset="13.76%" stopColor="#41873F"/><stop offset="40.32%" stopColor="#54A044"/><stop offset="71.36%" stopColor="#66B848"/><stop offset="90.81%" stopColor="#6CC04A"/></linearGradient><linearGradient id="logosNodejs2" x1="-4413.77%" x2="5327.93%" y1="13.43%" y2="13.43%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs3" x1="-4.389%" x2="101.499%" y1="49.997%" y2="49.997%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs4" x1="-9713.77%" x2="27.93%" y1="36.21%" y2="36.21%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs5" x1="-103.861%" x2="100.797%" y1="50.275%" y2="50.275%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs6" x1="130.613%" x2="4.393%" y1="-211.069%" y2="201.605%"><stop offset="0%" stopColor="#41873F"/><stop offset="32.88%" stopColor="#418B3D"/><stop offset="63.52%" stopColor="#419637"/><stop offset="93.19%" stopColor="#3FA92D"/><stop offset="100%" stopColor="#3FAE2A"/></linearGradient><path id="logosNodejs7" d="M57.903 1.85a5.957 5.957 0 0 0-5.894 0L3.352 29.933c-1.85 1.04-2.89 3.005-2.89 5.085v56.286c0 2.08 1.156 4.045 2.89 5.085l48.657 28.085a5.957 5.957 0 0 0 5.894 0l48.658-28.085c1.849-1.04 2.89-3.005 2.89-5.085V35.019c0-2.08-1.157-4.045-2.89-5.085L57.903 1.85Z"/></defs><g fill="none"><path fill="#539E43" d="M253.11 313.094c-1.733 0-3.351-.462-4.854-1.271l-15.371-9.13c-2.312-1.272-1.156-1.734-.462-1.965c3.12-1.04 3.698-1.272 6.934-3.12c.347-.232.81-.116 1.156.115l11.789 7.05c.462.231 1.04.231 1.386 0l46.115-26.698c.462-.231.694-.694.694-1.271v-53.28c0-.579-.232-1.04-.694-1.272l-46.115-26.582c-.462-.232-1.04-.232-1.386 0l-46.115 26.582c-.462.231-.694.809-.694 1.271v53.28c0 .463.232 1.04.694 1.272l12.598 7.281c6.819 3.467 11.095-.578 11.095-4.623v-52.587c0-.693.578-1.387 1.387-1.387h5.894c.694 0 1.387.578 1.387 1.387v52.587c0 9.13-4.97 14.447-13.638 14.447c-2.658 0-4.738 0-10.633-2.89l-12.135-6.934c-3.005-1.733-4.854-4.97-4.854-8.437v-53.28c0-3.467 1.849-6.704 4.854-8.437l46.114-26.698c2.89-1.618 6.82-1.618 9.709 0l46.114 26.698c3.005 1.733 4.855 4.97 4.855 8.437v53.28c0 3.467-1.85 6.704-4.855 8.437l-46.114 26.698c-1.503.694-3.236 1.04-4.854 1.04Zm14.216-36.637c-20.225 0-24.386-9.246-24.386-17.105c0-.694.578-1.387 1.387-1.387h6.01c.693 0 1.271.462 1.271 1.156c.925 6.125 3.583 9.13 15.834 9.13c9.708 0 13.87-2.196 13.87-7.397c0-3.005-1.157-5.2-16.297-6.703c-12.598-1.272-20.457-4.045-20.457-14.1c0-9.362 7.86-14.91 21.035-14.91c14.793 0 22.075 5.086 23 16.18c0 .348-.116.694-.347 1.041c-.232.231-.578.462-.925.462h-6.01c-.578 0-1.156-.462-1.271-1.04c-1.387-6.356-4.97-8.437-14.447-8.437c-10.633 0-11.905 3.699-11.905 6.472c0 3.352 1.503 4.392 15.834 6.241c14.216 1.85 20.92 4.508 20.92 14.447c-.116 10.171-8.437 15.95-23.116 15.95Z"/><path fill="#333" d="M110.028 104.712c0-2.08-1.156-4.046-3.005-5.086l-49.004-28.2c-.81-.463-1.734-.694-2.658-.81h-.463c-.924 0-1.849.347-2.658.81l-49.004 28.2c-1.85 1.04-3.005 3.005-3.005 5.086l.116 75.817c0 1.04.578 2.08 1.502 2.543c.925.578 2.08.578 2.89 0l29.125-16.643c1.849-1.04 3.005-3.005 3.005-5.085v-35.482c0-2.08 1.155-4.045 3.005-5.085l12.366-7.166c.925-.578 1.965-.81 3.005-.81c1.04 0 2.08.232 2.89.81l12.366 7.166c1.85 1.04 3.005 3.004 3.005 5.085v35.482c0 2.08 1.156 4.045 3.005 5.085l29.125 16.643a2.82 2.82 0 0 0 3.005 0c.925-.463 1.503-1.503 1.503-2.543l-.116-75.817ZM345.571.347c-.924-.463-2.08-.463-2.89 0c-.924.578-1.502 1.502-1.502 2.542v75.125c0 .693-.346 1.386-1.04 1.849c-.693.346-1.387.346-2.08 0l-12.251-7.05a5.957 5.957 0 0 0-5.895 0l-49.004 28.316c-1.849 1.04-3.005 3.005-3.005 5.085v56.516c0 2.08 1.156 4.046 3.005 5.086l49.004 28.316a5.957 5.957 0 0 0 5.895 0l49.004-28.316c1.849-1.04 3.005-3.005 3.005-5.086V21.844c0-2.196-1.156-4.16-3.005-5.201L345.572.347Zm-4.507 143.776c0 .578-.231 1.04-.694 1.271l-16.758 9.708a1.714 1.714 0 0 1-1.503 0l-16.758-9.708c-.463-.231-.694-.809-.694-1.271v-19.417c0-.578.231-1.04.694-1.271l16.758-9.709a1.714 1.714 0 0 1 1.503 0l16.758 9.709c.463.23.694.809.694 1.271v19.417Zm167.584-19.879c1.85-1.04 2.89-3.005 2.89-5.086v-13.753c0-2.08-1.156-4.045-2.89-5.085l-48.657-28.2a5.957 5.957 0 0 0-5.895 0l-49.004 28.315c-1.85 1.04-3.005 3.005-3.005 5.085v56.517c0 2.08 1.156 4.045 3.005 5.085l48.657 27.738c1.85 1.04 4.046 1.04 5.78 0L489 178.45c.925-.463 1.503-1.503 1.503-2.543c0-1.04-.578-2.08-1.503-2.543l-49.235-28.316c-.925-.578-1.503-1.502-1.503-2.542v-17.683c0-1.04.578-2.08 1.503-2.543l15.371-8.784a2.821 2.821 0 0 1 3.005 0l15.372 8.784c.925.578 1.502 1.502 1.502 2.543v13.869c0 1.04.578 2.08 1.503 2.542a2.82 2.82 0 0 0 3.005 0l29.125-16.99Z"/><path fill="#539E43" d="M456.292 121.585a1.05 1.05 0 0 1 1.156 0l9.362 5.432c.346.232.577.578.577 1.04v10.865c0 .462-.23.809-.577 1.04l-9.362 5.432a1.05 1.05 0 0 1-1.156 0l-9.361-5.432c-.347-.231-.578-.578-.578-1.04v-10.864c0-.463.23-.81.578-1.04l9.361-5.433Z"/><g transform="translate(134.068 70.501)"><mask id="logosNodejs8" fill="#fff"><use href="#logosNodejs7"/></mask><use fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs0)" href="#logosNodejs7"/><g mask="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs8)"><path d="M51.893 1.85L3.121 29.933C1.27 30.974 0 32.94 0 35.02v56.286c0 1.387.578 2.658 1.502 3.698L56.285 1.156c-1.387-.231-3.005-.116-4.392.693Zm4.739 123.203c.462-.116.925-.347 1.387-.578l48.773-28.085c1.85-1.04 3.005-3.005 3.005-5.085V35.019c0-1.502-.694-3.005-1.734-4.045l-51.43 94.079Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs1)" d="M106.676 29.934L57.788 1.85a8.025 8.025 0 0 0-1.503-.578L1.502 95.12a6.082 6.082 0 0 0 1.619 1.387l48.888 28.085c1.387.809 3.005 1.04 4.507.577l51.432-94.078c-.347-.462-.81-.81-1.272-1.156Z"/></g><g mask="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs8)"><path d="M109.797 91.305V35.019c0-2.08-1.271-4.045-3.12-5.085L57.786 1.85a5.106 5.106 0 0 0-1.848-.693l53.511 91.42c.231-.347.347-.809.347-1.271ZM3.12 29.934C1.272 30.974 0 32.94 0 35.02v56.286c0 2.08 1.387 4.045 3.12 5.085l48.889 28.085c1.156.693 2.427.925 3.814.693L3.467 29.818l-.346.116Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs2)" fillRule="evenodd" d="m50.391.809l-.693.347h.924l-.231-.347Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs3)" fillRule="evenodd" d="M106.792 105.636c1.387-.809 2.427-2.196 2.89-3.698L56.053 10.402c-1.387-.231-2.89-.116-4.16.693L3.351 39.065l52.355 95.465a8.057 8.057 0 0 0 2.196-.693l48.889-28.2Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs4)" fillRule="evenodd" d="m111.3 104.712l-.347-.578v.809l.346-.231Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs5)" fillRule="evenodd" d="m106.792 105.636l-48.773 28.085a6.973 6.973 0 0 1-2.196.693l.925 1.734l54.089-31.32v-.694l-1.387-2.312c-.231 1.618-1.271 3.005-2.658 3.814Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosNodejs6)" fillRule="evenodd" d="m106.792 105.636l-48.773 28.085a6.973 6.973 0 0 1-2.196.693l.925 1.734l54.089-31.32v-.694l-1.387-2.312c-.231 1.618-1.271 3.005-2.658 3.814Z" transform="translate(0 -9.246)"/></g></g></g></svg>
}
    href="/sdks/nodejs"
  >
    Connect your Node app to Novu via the Node.js SDK.
  </Card>

  <Card
    title="PHP"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#deviconPhp0)" d="M0 64c0 18.593 28.654 33.667 64 33.667c35.346 0 64-15.074 64-33.667c0-18.593-28.655-33.667-64-33.667C28.654 30.333 0 45.407 0 64Z"/><path fill="#777bb3" d="M64 95.167c33.965 0 61.5-13.955 61.5-31.167c0-17.214-27.535-31.167-61.5-31.167S2.5 46.786 2.5 64c0 17.212 27.535 31.167 61.5 31.167Z"/><path d="M34.772 67.864c2.793 0 4.877-.515 6.196-1.53c1.306-1.006 2.207-2.747 2.68-5.175c.44-2.27.272-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.464l-2.473 12.732zM20.173 83.547a.694.694 0 0 1-.68-.828l6.557-33.738a.695.695 0 0 1 .68-.561h14.134c4.442 0 7.748 1.206 9.827 3.585c2.088 2.39 2.734 5.734 1.917 9.935c-.333 1.711-.905 3.3-1.7 4.724a15.818 15.818 0 0 1-3.128 3.92c-1.531 1.432-3.264 2.472-5.147 3.083c-1.852.604-4.232.91-7.07.91h-5.724l-1.634 8.408a.695.695 0 0 1-.682.562z"/><path fill="#fff" d="M34.19 55.826h3.891c3.107 0 4.186.682 4.553 1.089c.607.674.723 2.097.331 4.112c-.439 2.257-1.253 3.858-2.42 4.756c-1.194.92-3.138 1.386-5.773 1.386h-2.786l2.205-11.342zm6.674-8.1H26.731a1.39 1.39 0 0 0-1.364 1.123L18.81 82.588a1.39 1.39 0 0 0 1.363 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.151c2.912 0 5.364-.318 7.287-.944c1.977-.642 3.796-1.731 5.406-3.237a16.522 16.522 0 0 0 3.259-4.087c.831-1.487 1.429-3.147 1.775-4.931c.86-4.423.161-7.964-2.076-10.524c-2.216-2.537-5.698-3.823-10.349-3.823zM30.301 68.557h4.471c2.963 0 5.17-.557 6.62-1.675c1.451-1.116 2.428-2.98 2.938-5.591c.485-2.508.264-4.277-.665-5.308c-.931-1.03-2.791-1.546-5.584-1.546h-5.036l-2.743 14.12m10.563-19.445c4.252 0 7.353 1.117 9.303 3.348c1.95 2.232 2.536 5.347 1.76 9.346c-.322 1.648-.863 3.154-1.625 4.518c-.764 1.366-1.76 2.614-2.991 3.747c-1.468 1.373-3.097 2.352-4.892 2.935c-1.794.584-4.08.875-6.857.875h-6.296l-1.743 8.97h-7.35l6.558-33.739h14.133"/><path d="M69.459 74.577a.694.694 0 0 1-.682-.827l2.9-14.928c.277-1.42.209-2.438-.19-2.87c-.245-.263-.979-.704-3.15-.704h-5.256l-3.646 18.768a.695.695 0 0 1-.683.56h-7.29a.695.695 0 0 1-.683-.826l6.558-33.739a.695.695 0 0 1 .682-.561h7.29a.695.695 0 0 1 .683.826L64.41 48.42h5.653c4.307 0 7.227.758 8.928 2.321c1.733 1.593 2.275 4.14 1.608 7.573l-3.051 15.702a.695.695 0 0 1-.682.56h-7.407z"/><path fill="#fff" d="M65.31 38.755h-7.291a1.39 1.39 0 0 0-1.364 1.124l-6.557 33.738a1.39 1.39 0 0 0 1.363 1.654h7.291a1.39 1.39 0 0 0 1.364-1.124l3.537-18.205h4.682c2.168 0 2.624.463 2.641.484c.132.14.305.795.019 2.264l-2.9 14.927a1.39 1.39 0 0 0 1.364 1.654h7.408a1.39 1.39 0 0 0 1.363-1.124l3.051-15.7c.715-3.686.103-6.45-1.82-8.217c-1.836-1.686-4.91-2.505-9.398-2.505h-4.81l1.421-7.315a1.39 1.39 0 0 0-1.364-1.655zm0 1.39l-1.743 8.968h6.496c4.087 0 6.907.714 8.457 2.14c1.553 1.426 2.017 3.735 1.398 6.93l-3.052 15.699h-7.407l2.901-14.928c.33-1.698.208-2.856-.365-3.474c-.573-.617-1.793-.926-3.658-.926h-5.829l-3.756 19.327H51.46l6.558-33.739h7.292z"/><path d="M92.136 67.864c2.793 0 4.878-.515 6.198-1.53c1.304-1.006 2.206-2.747 2.679-5.175c.44-2.27.273-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.463l-2.475 12.732zM77.54 83.547a.694.694 0 0 1-.682-.828l6.557-33.738a.695.695 0 0 1 .682-.561H98.23c4.442 0 7.748 1.206 9.826 3.585c2.089 2.39 2.734 5.734 1.917 9.935a15.878 15.878 0 0 1-1.699 4.724a15.838 15.838 0 0 1-3.128 3.92c-1.53 1.432-3.265 2.472-5.147 3.083c-1.852.604-4.232.91-7.071.91h-5.723l-1.633 8.408a.695.695 0 0 1-.683.562z"/><path fill="#fff" d="M91.555 55.826h3.891c3.107 0 4.186.682 4.552 1.089c.61.674.724 2.097.333 4.112c-.44 2.257-1.254 3.858-2.421 4.756c-1.195.92-3.139 1.386-5.773 1.386h-2.786l2.204-11.342zm6.674-8.1H84.096a1.39 1.39 0 0 0-1.363 1.123l-6.558 33.739a1.39 1.39 0 0 0 1.364 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.15c2.911 0 5.364-.318 7.286-.944c1.978-.642 3.797-1.731 5.408-3.238a16.52 16.52 0 0 0 3.258-4.086c.832-1.487 1.428-3.147 1.775-4.931c.86-4.423.162-7.964-2.076-10.524c-2.216-2.537-5.697-3.823-10.35-3.823zM87.666 68.557h4.47c2.964 0 5.17-.557 6.622-1.675c1.45-1.116 2.428-2.98 2.936-5.591c.487-2.508.266-4.277-.665-5.308c-.93-1.03-2.791-1.546-5.583-1.546h-5.035Zm10.563-19.445c4.251 0 7.354 1.117 9.303 3.348c1.95 2.232 2.537 5.347 1.759 9.346c-.32 1.648-.862 3.154-1.624 4.518c-.763 1.366-1.76 2.614-2.992 3.747c-1.467 1.373-3.097 2.352-4.892 2.935c-1.793.584-4.078.875-6.856.875h-6.295l-1.745 8.97h-7.35l6.558-33.739h14.133"/><defs><radialGradient id="deviconPhp0" cx="0" cy="0" r="1" gradientTransform="translate(38.426 42.169) scale(84.04136)" gradientUnits="userSpaceOnUse"><stop stopColor="#AEB2D5"/><stop offset=".3" stopColor="#AEB2D5"/><stop offset=".75" stopColor="#484C89"/><stop offset="1" stopColor="#484C89"/></radialGradient></defs></svg>
}
    href="/sdks/php"
  >
    Connect your PHP app to Novu via the PHP SDK.
  </Card>

  <Card title="Laravel" icon="laravel" href="/sdks/laravel">
    Connect your Laravel app to Novu via the Laravel SDK.
  </Card>

  <Card
    title="Python"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="34.87" viewBox="0 0 256 255"><defs><linearGradient id="logosPython0" x1="12.959%" x2="79.639%" y1="12.039%" y2="78.201%"><stop offset="0%" stopColor="#387EB8"/><stop offset="100%" stopColor="#366994"/></linearGradient><linearGradient id="logosPython1" x1="19.128%" x2="90.742%" y1="20.579%" y2="88.429%"><stop offset="0%" stopColor="#FFE052"/><stop offset="100%" stopColor="#FFC331"/></linearGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosPython0)" d="M126.916.072c-64.832 0-60.784 28.115-60.784 28.115l.072 29.128h61.868v8.745H41.631S.145 61.355.145 126.77c0 65.417 36.21 63.097 36.21 63.097h21.61v-30.356s-1.165-36.21 35.632-36.21h61.362s34.475.557 34.475-33.319V33.97S194.67.072 126.916.072ZM92.802 19.66a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.13Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosPython1)" d="M128.757 254.126c64.832 0 60.784-28.115 60.784-28.115l-.072-29.127H127.6v-8.745h86.441s41.486 4.705 41.486-60.712c0-65.416-36.21-63.096-36.21-63.096h-21.61v30.355s1.165 36.21-35.632 36.21h-61.362s-34.475-.557-34.475 33.32v56.013s-5.235 33.897 62.518 33.897Zm34.114-19.586a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.131a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13Z"/></svg>
}
    href="/sdks/python"
  >
    Connect your Python app to Novu via the Python SDK.
  </Card>

  <Card
    title="Kotlin"
    icon={
<svg
    xmlns="http://www.w3.org/2000/svg"
    width="20"
    height="20"
    viewBox="0 0 256 256"
  >
    <defs>
      <linearGradient
        id="logosKotlinIcon0"
        x1="99.991%"
        x2=".01%"
        y1="-.011%"
        y2="100.01%"
      >
        <stop offset=".344%" stopColor="#E44857" />
        <stop offset="46.89%" stopColor="#C711E1" />
        <stop offset="100%" stopColor="#7F52FF" />
      </linearGradient>
    </defs>
    <path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosKotlinIcon0)" d="M256 256H0V0h256L128 127.949z" />
  </svg>}
    href="/quickstarts/kotlin"
  >
    Connect your Kotlin app to Novu via the Kotlin SDK.
  </Card>

  <Card
    title="Java"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="#0074BD" d="M47.617 98.12s-4.767 2.774 3.397 3.71c9.892 1.13 14.947.968 25.845-1.092c0 0 2.871 1.795 6.873 3.351c-24.439 10.47-55.308-.607-36.115-5.969zm-2.988-13.665s-5.348 3.959 2.823 4.805c10.567 1.091 18.91 1.18 33.354-1.6c0 0 1.993 2.025 5.132 3.131c-29.542 8.64-62.446.68-41.309-6.336z"/><path fill="#EA2D2E" d="M69.802 61.271c6.025 6.935-1.58 13.17-1.58 13.17s15.289-7.891 8.269-17.777c-6.559-9.215-11.587-13.792 15.635-29.58c0 .001-42.731 10.67-22.324 34.187z"/><path fill="#0074BD" d="M102.123 108.229s3.529 2.91-3.888 5.159c-14.102 4.272-58.706 5.56-71.094.171c-4.451-1.938 3.899-4.625 6.526-5.192c2.739-.593 4.303-.485 4.303-.485c-4.953-3.487-32.013 6.85-13.743 9.815c49.821 8.076 90.817-3.637 77.896-9.468zM49.912 70.294s-22.686 5.389-8.033 7.348c6.188.828 18.518.638 30.011-.326c9.39-.789 18.813-2.474 18.813-2.474s-3.308 1.419-5.704 3.053c-23.042 6.061-67.544 3.238-54.731-2.958c10.832-5.239 19.644-4.643 19.644-4.643zm40.697 22.747c23.421-12.167 12.591-23.86 5.032-22.285c-1.848.385-2.677.72-2.677.72s.688-1.079 2-1.543c14.953-5.255 26.451 15.503-4.823 23.725c0-.002.359-.327.468-.617z"/><path fill="#EA2D2E" d="M76.491 1.587S89.459 14.563 64.188 34.51c-20.266 16.006-4.621 25.13-.007 35.559c-11.831-10.673-20.509-20.07-14.688-28.815C58.041 28.42 81.722 22.195 76.491 1.587z"/><path fill="#0074BD" d="M52.214 126.021c22.476 1.437 57-.8 57.817-11.436c0 0-1.571 4.032-18.577 7.231c-19.186 3.612-42.854 3.191-56.887.874c0 .001 2.875 2.381 17.647 3.331z"/></svg>
}
    href="/sdks/java"
  >
    Connect your Java app to Novu via the Java SDK.
  </Card>

  <Card
    title="Ruby"
    icon={<svg xmlns="http://www.w3.org/2000/svg" width="20" height="19.93" viewBox="0 0 256 255"><defs><linearGradient id="logosRuby0" x1="84.75%" x2="58.254%" y1="111.399%" y2="64.584%"><stop offset="0%" stopColor="#FB7655"/><stop offset="0%" stopColor="#FB7655"/><stop offset="41%" stopColor="#E42B1E"/><stop offset="99%" stopColor="#900"/><stop offset="100%" stopColor="#900"/></linearGradient><linearGradient id="logosRuby1" x1="116.651%" x2="1.746%" y1="60.89%" y2="19.288%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby2" x1="75.774%" x2="38.978%" y1="219.327%" y2="7.829%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby3" x1="50.012%" x2="66.483%" y1="7.234%" y2="79.135%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E57252"/><stop offset="46%" stopColor="#DE3B20"/><stop offset="99%" stopColor="#A60003"/><stop offset="100%" stopColor="#A60003"/></linearGradient><linearGradient id="logosRuby4" x1="46.174%" x2="49.932%" y1="16.348%" y2="83.047%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E4714E"/><stop offset="56%" stopColor="#BE1A0D"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby5" x1="36.965%" x2="49.528%" y1="15.594%" y2="92.478%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="18%" stopColor="#E46342"/><stop offset="40%" stopColor="#C82410"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby6" x1="13.609%" x2="85.764%" y1="58.346%" y2="-46.717%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="54%" stopColor="#C81F11"/><stop offset="99%" stopColor="#BF0905"/><stop offset="100%" stopColor="#BF0905"/></linearGradient><linearGradient id="logosRuby7" x1="27.624%" x2="50.745%" y1="21.135%" y2="79.056%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="31%" stopColor="#DE4024"/><stop offset="99%" stopColor="#BF190B"/><stop offset="100%" stopColor="#BF190B"/></linearGradient><linearGradient id="logosRuby8" x1="-20.667%" x2="104.242%" y1="122.282%" y2="-6.342%"><stop offset="0%" stopColor="#BD0012"/><stop offset="0%" stopColor="#BD0012"/><stop offset="7%" stopColor="#FFF"/><stop offset="17%" stopColor="#FFF"/><stop offset="27%" stopColor="#C82F1C"/><stop offset="33%" stopColor="#820C01"/><stop offset="46%" stopColor="#A31601"/><stop offset="72%" stopColor="#B31301"/><stop offset="99%" stopColor="#E82609"/><stop offset="100%" stopColor="#E82609"/></linearGradient><linearGradient id="logosRuby9" x1="58.792%" x2="11.964%" y1="65.205%" y2="50.128%"><stop offset="0%" stopColor="#8C0C01"/><stop offset="0%" stopColor="#8C0C01"/><stop offset="54%" stopColor="#990C00"/><stop offset="99%" stopColor="#A80D0E"/><stop offset="100%" stopColor="#A80D0E"/></linearGradient><linearGradient id="logosRubya" x1="79.319%" x2="23.088%" y1="62.754%" y2="17.888%"><stop offset="0%" stopColor="#7E110B"/><stop offset="0%" stopColor="#7E110B"/><stop offset="99%" stopColor="#9E0C00"/><stop offset="100%" stopColor="#9E0C00"/></linearGradient><linearGradient id="logosRubyb" x1="92.88%" x2="59.841%" y1="74.122%" y2="39.704%"><stop offset="0%" stopColor="#79130D"/><stop offset="0%" stopColor="#79130D"/><stop offset="99%" stopColor="#9E120B"/><stop offset="100%" stopColor="#9E120B"/></linearGradient><linearGradient id="logosRubyc" x1="56.57%" x2="3.105%" y1="101.717%" y2="11.993%"><stop offset="0%" stopColor="#8B2114"/><stop offset="0%" stopColor="#8B2114"/><stop offset="43%" stopColor="#9E100A"/><stop offset="99%" stopColor="#B3100C"/><stop offset="100%" stopColor="#B3100C"/></linearGradient><linearGradient id="logosRubyd" x1="30.87%" x2="92.471%" y1="35.599%" y2="100.694%"><stop offset="0%" stopColor="#B31000"/><stop offset="0%" stopColor="#B31000"/><stop offset="44%" stopColor="#910F08"/><stop offset="99%" stopColor="#791C12"/><stop offset="100%" stopColor="#791C12"/></linearGradient><radialGradient id="logosRubye" cx="32.001%" cy="40.21%" r="69.573%" fx="32.001%" fy="40.21%"><stop offset="0%" stopColor="#A80D00"/><stop offset="0%" stopColor="#A80D00"/><stop offset="99%" stopColor="#7E0E08"/><stop offset="100%" stopColor="#7E0E08"/></radialGradient><radialGradient id="logosRubyf" cx="13.549%" cy="40.86%" r="88.386%" fx="13.549%" fy="40.86%"><stop offset="0%" stopColor="#A30C00"/><stop offset="0%" stopColor="#A30C00"/><stop offset="99%" stopColor="#800E08"/><stop offset="100%" stopColor="#800E08"/></radialGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby0)" d="m197.467 167.764l-145.52 86.41l188.422-12.787L254.88 51.393l-57.414 116.37Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby1)" d="M240.677 241.257L224.482 129.48l-44.113 58.25l60.308 53.528Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby2)" d="m240.896 241.257l-118.646-9.313l-69.674 21.986l188.32-12.673Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby3)" d="m52.744 253.955l29.64-97.1L17.16 170.8l35.583 83.154Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby4)" d="M180.358 188.05L153.085 81.226l-78.047 73.16l105.32 33.666Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby5)" d="m248.693 82.73l-73.777-60.256l-20.544 66.418l94.321-6.162Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby6)" d="M214.191.99L170.8 24.97L143.424.669l70.767.322Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby7)" d="m0 203.372l18.177-33.151l-14.704-39.494L0 203.372Z"/><path fill="#FFF" d="m2.496 129.48l14.794 41.963l64.283-14.422l73.39-68.207l20.712-65.787L143.063 0L87.618 20.75c-17.469 16.248-51.366 48.396-52.588 49c-1.21.618-22.384 40.639-32.534 59.73Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby8)" d="M54.442 54.094c37.86-37.538 86.667-59.716 105.397-40.818c18.72 18.898-1.132 64.823-38.992 102.349c-37.86 37.525-86.062 60.925-104.78 42.027c-18.73-18.885.515-66.032 38.375-103.558Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRuby9)" d="m52.744 253.916l29.408-97.409l97.665 31.376c-35.312 33.113-74.587 61.106-127.073 66.033Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubya)" d="m155.092 88.622l25.073 99.313c29.498-31.016 55.972-64.36 68.938-105.603l-94.01 6.29Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubyb)" d="M248.847 82.833c10.035-30.282 12.35-73.725-34.966-81.791l-38.825 21.445l73.791 60.346Z"/><path fill="#9E1209" d="M0 202.935c1.39 49.979 37.448 50.724 52.808 51.162l-35.48-82.86L0 202.935Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubye)" d="M155.232 88.777c22.667 13.932 68.35 41.912 69.276 42.426c1.44.81 19.695-30.784 23.838-48.64l-93.114 6.214Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubyf)" d="m82.113 156.507l39.313 75.848c23.246-12.607 41.45-27.967 58.121-44.42l-97.434-31.428Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubyc)" d="m17.174 171.34l-5.57 66.328c10.51 14.357 24.97 15.605 40.136 14.486c-10.973-27.311-32.894-81.92-34.566-80.814Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/sdks#logosRubyd)" d="m174.826 22.654l78.1 10.96c-4.169-17.662-16.969-29.06-38.787-32.623l-39.313 21.663Z"/></svg>

}
    href="/quickstarts/ruby"
  >
    Connect your Ruby app to Novu via the Ruby SDK.
  </Card>

  <Card
    title="Go"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="13.13" viewBox="0 0 512 192"><path fill="#00ACD7" d="m292.533 13.295l1.124.75c13.212 8.725 22.685 20.691 28.917 35.15c1.496 2.243.499 3.49-2.493 4.237l-5.063 1.296c-11.447 2.949-20.53 5.429-31.827 8.378l-6.443 1.678c-2.32.574-2.96.333-5.428-2.477l-.348-.399c-3.519-3.988-6.155-6.652-10.817-9.03l-.899-.443c-15.705-7.727-30.911-5.484-45.12 3.74c-16.952 10.968-25.677 27.172-25.428 47.364c.25 19.942 13.96 36.395 33.654 39.137c16.951 2.244 31.16-3.739 42.378-16.452c2.244-2.743 4.238-5.734 6.73-9.224h-48.11c-5.235 0-6.481-3.24-4.736-7.478l.864-2.035c3.204-7.454 8.173-18.168 11.4-24.294l.704-1.319c.862-1.494 2.612-3.513 5.977-3.513h80.224c3.603-11.415 9.449-22.201 17.246-32.407c18.198-23.931 40.135-36.396 69.8-41.63c25.427-4.488 49.359-1.995 71.046 12.713c19.694 13.461 31.909 31.66 35.15 55.59c4.237 33.654-5.485 61.075-28.668 84.508c-16.453 16.702-36.645 27.172-59.829 31.908c-6.73 1.247-13.461 1.496-19.942 2.244c-22.685-.499-43.376-6.98-60.826-21.937c-12.273-10.61-20.727-23.648-24.928-38.828a104.937 104.937 0 0 1-10.47 16.89c-17.949 23.683-41.381 38.39-71.046 42.38c-24.43 3.24-47.115-1.497-67.058-16.454c-18.447-13.96-28.917-32.407-31.66-55.34c-3.24-27.173 4.737-51.603 21.19-73.041c17.7-23.184 41.132-37.891 69.8-43.126c22.999-4.16 45.037-1.595 64.936 11.464ZM411.12 49.017l-.798.178c-23.183 5.235-38.14 19.942-43.624 43.375c-4.488 19.444 4.985 39.138 22.934 47.115c13.71 5.983 27.421 5.235 40.633-1.496c19.694-10.22 30.413-26.175 31.66-47.613c-.25-3.24-.25-5.734-.749-8.227c-4.436-24.401-26.664-38.324-50.056-33.332ZM116.416 94.564c.997 0 1.496.748 1.496 1.745l-.499 5.983c0 .997-.997 1.745-1.745 1.745l-54.344-.249c-.997 0-1.246-.748-.748-1.496l3.49-6.232c.499-.748 1.496-1.496 2.493-1.496h49.857ZM121.9 71.63c.997 0 1.496.748 1.247 1.496l-1.995 5.983c-.249.997-1.246 1.495-2.243 1.495l-117.912.25c-.997 0-1.246-.499-.748-1.247l5.235-6.73c.499-.748 1.745-1.247 2.742-1.247H121.9Zm12.963-22.934c.997 0 1.246.748.748 1.496l-4.238 6.481c-.499.748-1.745 1.496-2.493 1.496l-90.24-.25c-.998 0-1.247-.498-.749-1.246l5.235-6.73c.499-.748 1.745-1.247 2.742-1.247h88.995Z"/></svg>
}
    href="/sdks/go"
  >
    Connect your Golang app to Novu via the Go SDK.
  </Card>

  <Card
    title=".NET"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 256 256"><g fill="none"><rect width="256" height="256" fill="#512BD4" rx="60"/><path fill="#fff" d="M24.052 168.943c-2.236 0-4.138-.731-5.703-2.194c-1.566-1.501-2.349-3.283-2.349-5.347c0-2.101.783-3.902 2.349-5.403c1.565-1.5 3.466-2.251 5.703-2.251c2.274 0 4.194.751 5.76 2.251c1.603 1.501 2.404 3.302 2.404 5.403c0 2.064-.801 3.846-2.404 5.347c-1.566 1.463-3.486 2.194-5.76 2.194Zm89.415-1.238H98.929l-38.304-59.318a26.371 26.371 0 0 1-2.404-4.672h-.336c.298 1.726.447 5.422.447 11.087v52.903H45.471V87H60.96l37.018 57.912c1.566 2.402 2.572 4.052 3.02 4.953h.223c-.372-2.139-.559-5.759-.559-10.863V87h12.805v80.705Zm62.631 0h-45.014V87h43.225v11.369h-29.916v22.849h27.568v11.312h-27.568v23.863h31.705v11.312Zm63.973-69.336h-23.038v69.336h-13.309V98.369h-22.982V87h59.329v11.369Z"/></g></svg>
}
    href="/sdks/dotnet"
  >
    Connect your C#/.NET app to Novu via the .NET SDK.
  </Card>
</CardGroup>


# Java SDK
Source: https://v0.x-docs.novu.co/sdks/java

Connect a Java application to Novu

Novu's Java SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Java application.

[Explore the source code on GitHub.](https://github.com/novuhq/novu-java)

## Installation

Maven users:

```java theme={null}
<!--add dependency-->
<dependency>
    <groupId>co.novu</groupId>
    <artifactId>novu-java</artifactId>
    <version>{use-latest-version}</version>
</dependency>
```

The latest version can be found [on GitHub.](https://github.com/novuhq/novu-java#installation)

Gradle users:

```groovy theme={null}
implementation 'co.novu:novu-java:{latest-version}'
```

Sync your project, and you should have the artifacts downloaded.

<Tip> If you're ready to start integrating in your Java app, jump straight to our [Java quickstart.](/quickstarts/java)</Tip>

## Usage

```java theme={null}
import co.novu.sdk.Novu;

public class Main {
    public static void main(String[] args) {
        String apiKey = "INSERT_API_KEY_HERE";
        // Using the API Key only
        Novu novu = new Novu(apiKey);

        // Using the Config Param
        NovuConfig novuConfig = new NovuConfig(apiKey);
        Novu novu = new Novu(novuConfig);

        // Sample usage
        novu.triggerEvent(event);
    }
}

// Sign up on https://web.novu.co and grab your API key from https://web.novu.co/settings
```


# Kotlin SDK
Source: https://v0.x-docs.novu.co/sdks/kotlin

Connect a Kotlin application to Novu

Novu's Kotlin SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Kotlin application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-kotlin)

## Installation

Maven users:

```xml theme={null}
<dependency>
  <groupId>co.novu</groupId>
  <artifactId>novu-kotlin</artifactId>
  <version>{use-latest-version}</version>
</dependency>
```

The latest version can be found [on GitHub.](https://github.com/novuhq/novu-kotlin#installation)

Gradle users:

```groovy theme={null}
implementation 'co.novu:novu-kotlin:{use-latest-version}' //Groovy

implementation ("co.novu:novu-kotlin:{use-latest-version}") //Kotlin
```

Sync your project, and you should have the artifacts downloaded.

<Tip> If you're ready to start integrating in your Kotlin app, jump straight to our [Kotlin quickstart.](/quickstarts/kotlin)</Tip>

## Usage

```kotlin theme={null}

// without changing the backend URL
import co.novu.Novu
import co.novu.extentions.environments

fun main() {
    val novu = Novu(apiKey = "NOVU_API_KEY")
    val environment = novu.environments()
    println(environment)
}

```


# Laravel
Source: https://v0.x-docs.novu.co/sdks/laravel

Connect a Laravel application to Novu

Novu's Laravel SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Laravel application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-laravel)

## Installation

```php theme={null}
composer require novu/novu-laravel
```

<Tip> If you're ready to start integrating in your Laravel app, jump straight to our [Laravel quickstart.]()</Tip>

## Usage

```php theme={null}
use Novu\Laravel\Facades\Novu;

$response = Novu::triggerEvent([
    'name' => '<WORKFLOW_TRIGGER_IDENTIFIER_FROM_DASHBOARD>',
    'payload' => ['customVariables' => 'Hello'],
    'to' => [
        'subscriberId' => '<SUBSCRIBER_ID_FROM_DASHBOARD>',
        'phone' => '07983887777'
    ]
])->toArray();

// or you can use the novu() helper function like so:
novu()->triggerEvent([
    'name' => '<WORKFLOW_TRIGGER_IDENTIFIER_FROM_DASHBOARD>',
    'payload' => ['customVariables' => 'Hello'],
    'to' => [
        'subscriberId' => '<SUBSCRIBER_ID_FROM_DASHBOARD>',
        'phone' => '07983887777'
    ]
])->toArray();
```


# NodeJS SDK
Source: https://v0.x-docs.novu.co/sdks/nodejs

Connect a Node.js application to Novu

Novu's Node.js SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Node.js application.

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/node)

## Installation

```javascript theme={null}
npm install @novu/node 
```

<Tip> If you're ready to start integrating in your Node.js app, jump straight to our [Nodejs quickstart.](/quickstarts/nodejs)</Tip>

## Usage

```javascript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<USER_IDENTIFIER>',
    email: 'test@email.com',
    firstName: 'John',
    lastName: 'Doe',
  },
  payload: {
    organization: {
      logo: 'https://evilcorp.com/logo.png',
    },
  },
});
```


# PHP SDK
Source: https://v0.x-docs.novu.co/sdks/php

Connect a PHP application to Novu

Novu's PHP SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your PHP application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-php)

## Installation

```php theme={null}
composer require unicodeveloper/novu
```

<Tip> If you're ready to start integrating in your PHP app, jump straight to our [PHP quickstart.](/quickstarts/php)</Tip>

## Usage

```php theme={null}
use Novu\SDK\Novu;

$novu = new Novu(<INSERT_API_KEY_HERE>);

// Sign up on https://web.novu.co and grab your API key from https://web.novu.co/settings

$response = $novu->triggerEvent([
    'name' => '<REPLACE_WITH_TEMPLATE_NAME_FROM_ADMIN_PANEL>',
    'payload' => ['customVariables' => 'Hello'],
    'to' => [
        'subscriberId' => '<SUBSCRIBER_IDENTIFIER_FROM_ADMIN_PANEL>',
        'phone' => '07983882186'
    ]
])->toArray();
```


# Python SDK
Source: https://v0.x-docs.novu.co/sdks/python

Connect a Python application to Novu

Novu's Python SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Python application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-python)

## Installation

```python theme={null}
# Via pip
pip install novu

# Via poetry
poetry add novu
```

<Tip> If you're ready to start integrating in your Python app, jump straight to our [Python quickstart.](/quickstarts/python)</Tip>

## Usage

```python theme={null}
from novu.api import EventApi

url = "https://api.novu.co"
api_key = "<NOVU_API_KEY>"

# You can sign up on https://web.novu.co to get your API key from https://web.novu.co/settings

novu = EventApi(url, api_key).trigger(
    name="digest-workflow-example",  # This is the Workflow ID. It can be found on the workflow page.
    recipients="<SUBSCRIBER_IDENTIFIER>", # The subscriber ID can be gotten from the dashboard.
    payload={},  # Your custom Novu payload goes here
)
```


# React Component
Source: https://v0.x-docs.novu.co/sdks/react

Novu’s React library provides a fully functional and embeddable notification center component with real-time updates that you can drop into your React application.

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/notification-center)

## Installation

```javascript theme={null}
npm install @novu/notification-center
```

<Tip> If you're ready to start integrating in your React app, jump straight to our [quickstart](/quickstarts/react)</Tip>

Learn more about usage of the [React Component in detail.](/notification-center/client/react/get-started)


# Ruby SDK
Source: https://v0.x-docs.novu.co/sdks/ruby

Connect a Ruby application to Novu.

Novu's Ruby SDK provides simple, yet comprehensive notification management, and delivery capabilities through multiple channels that you can implement using code that integrates seamlessly with your Ruby application.

[Explore the source code on GitHub](https://github.com/novuhq/novu-ruby)

## Installation

```javascript theme={null}
gem install novu
```

<Tip> If you're ready to start integrating in your Ruby app, jump straight to our [Ruby quickstart.](/quickstarts/ruby)</Tip>

## Usage

```ruby theme={null}
require 'novu'

client = Novu::Client.new(access_token: 'YOUR_NOVU_API_TOKEN')

payload = {
    'name' => 'Trigger1',
    'payload' => { # optional
        'first-name' => 'Adam' # optional
    },
    'to' => {
        'subscriberId' => '7789'
    },
    'transactionId' => '89kjfke9893' #optional
}

client.trigger_event(payload)
```


# Vue library
Source: https://v0.x-docs.novu.co/sdks/vue

Novu’s Vue library provides a Vue component wrapper over the Notification Center Web that you can use to integrate the notification center into your Vue application. 

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/notification-center-vue)

## Installation

```javascript theme={null}
npm install @novu/notification-center-vue
```

<Tip> If you're ready to start integrating in your Vue app, jump straight to the [Vue quickstart.](/quickstarts/vue)</Tip>

Learn more about usage of the [Vue Component in detail.](/notification-center/client/vue)


# Web Component Library
Source: https://v0.x-docs.novu.co/sdks/web-component

Novu’s Web Component library provides a fully functional and embeddable notification center widget with real-time updates that you can drop into any web application.

[Explore the source code on GitHub](https://github.com/novuhq/novu/tree/next/packages/notification-center)

## Installation

You can use the web component in two ways:

* As an ESM Module
* As a bundled CDN version

<Tip> If you're ready to start integrating in your web app, jump straight to the [Web component quickstart.](/quickstarts/vanillajs)</Tip>

Learn more about usage of the [Web Component in detail.](/notification-center/client/web-component)


# Apply change
Source: https://v0.x-docs.novu.co/api-reference/changes/apply-change

post /v1/changes/{changeId}/apply

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.changes.applyOne("changeId");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->applyChange($changeId, []);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.apply_change(`<change_id≥`)
  ```

  ```python Python theme={null}
  from novu.api import ChangeApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = ChangeApi(url, api_key).apply(
      change_id = "<A change ID to apply>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.applyChange('changeId');
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "_creatorId": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_entityId": "string",
        "enabled": true,
        "type": "Feed",
        "change": {},
        "createdAt": "string",
        "_parentId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Apply changes
Source: https://v0.x-docs.novu.co/api-reference/changes/apply-changes

post /v1/changes/bulk/apply

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.changes.applyMany(["changeId1", "changeId2"]);
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->applyBulkChanges([
      'changeIds' = [
          '<insert-all-the-change-ids>'
      ]
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.apply_change({
      'changeIds' => ['<insert-all-the-change-ids>']
  })
  ```

  ```python Python theme={null}
  from novu.api import ChangeApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = ChangeApi(url, api_key).bulk_apply(
      change_ids = "<The list of IDs to apply>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.applyBulkChanges("<list-of-change-ids>");
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "_creatorId": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_entityId": "string",
        "enabled": true,
        "type": "Feed",
        "change": {},
        "createdAt": "string",
        "_parentId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Get changes
Source: https://v0.x-docs.novu.co/api-reference/changes/get-changes

get /v1/changes

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.changes.get();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getChanges();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.changes({
      'page' => 1, # optional
      'limit' => 10, # optional
      'promoted' => 'hello'
  })
  ```

  ```python Python theme={null}
  from novu.api import ChangeApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = ChangeApi(url, api_key).list(
      page = "<Page to retrieve>",
      limit = "<Size of page>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.changes(query = {});
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      totalCount: 0,
      data: [data],
      pageSize: 0,
      page: 0
  }
  ```
</ResponseExample>


# Get changes count
Source: https://v0.x-docs.novu.co/api-reference/changes/get-changes-count

get /v1/changes/count

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.changes.getCount();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getChangesCount()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.count_changes()
  ```

  ```python Python theme={null}
  from novu.api import ChangeApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = ChangeApi(url, api_key).count(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.countChanges();
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      data: 0
  }
  ```
</ResponseExample>


# Get api keys
Source: https://v0.x-docs.novu.co/api-reference/environments/get-api-keys

get /v1/environments/api-keys

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.environmets.getApiKeys();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getEnvironmentsAPIKeys()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.api_keys()
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.apiKeys();
      }
  }
  ```

  ```python Python theme={null}
  from novu.api import EnvironmentApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  apiKeys = EnvironmentApi(url, api_key).api_keys()
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.apiKeys

  fun main() {
      val novu = Novu(apiKey = "API_KEY")
      val apiKeys = novu.apiKeys()
      println(apiKeys)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
       --url https://api.novu.co/v1/environments/api-keys \
       --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "key": "string",
        "_userId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Get current environment
Source: https://v0.x-docs.novu.co/api-reference/environments/get-current-environment

get /v1/environments/me

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.environments.getCurrent();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->getCurrentEnvironment()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.current_environment()
  ```

  ```python Python theme={null}
  from novu.api import EnvironmentApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = EnvironmentApi(url, api_key).current(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.currentEnvironment();
      }
  }
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.currentEnvironment

  fun main() {
      val novu = Novu(apiKey = "API_KEY")
      val currentEnvironment = novu.currentEnvironment()
      println(currentEnvironment)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
       --url https://api.novu.co/v1/environments/me \
       --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "_organizationId": "string",
      "identifier": "string",
      "apiKeys": [
        {
          "key": "string",
          "_userId": "string"
        }
      ],
      "_parentId": "string"
    }
  }
  ```
</ResponseExample>


# List all environments
Source: https://v0.x-docs.novu.co/api-reference/environments/get-environments

get /v1/environments
This API returns a list of environments for the current organization. 
    Each environment contains its configuration, API keys (if user has access), and metadata.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.environments.getAll();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getEnvironments()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.environments()
  ```

  ```python Python theme={null}
  from novu.api import EnvironmentApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = EnvironmentApi(url, api_key).list(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.environments();
      }
  }
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.environments

  fun main() {
      val novu = Novu(apiKey = "API_KEY")
      val environment = novu.environments()
      println(environment)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
       --url https://api.novu.co/v1/environments \
       --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "name": "string",
        "_organizationId": "string",
        "identifier": "string",
        "apiKeys": [
          {
            "key": "string",
            "_userId": "string"
          }
        ],
        "_parentId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Regenerate api keys
Source: https://v0.x-docs.novu.co/api-reference/environments/regenerate-api-keys

post /v1/environments/api-keys/regenerate

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.environmets.regenerateApiKeys();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $key = $novu->regenerateEnvironmentsAPIKeys()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.regenerate_api_keys()
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.regenerateApiKeys();
      }
  }
  ```

  ```python Python theme={null}
  from novu.api import EnvironmentApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  regenerateApiKey = EnvironmentApi(url, api_key).regenerate_api_key()
  ```

  ```bash cURL theme={null}
  curl --request POST \
       --url https://api.novu.co/v1/environments/api-keys/regenerate \
       --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "key": "string",
        "_userId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Get execution details
Source: https://v0.x-docs.novu.co/api-reference/execution-details/get-execution-details

get /v1/execution-details

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request GET \
      --url https://api.novu.co/v1/execution-details \
      --header 'Authorization: <authorization>' 
  ```

  ```javascript Node.js theme={null}
  import fetch from 'node-fetch';

  const response = await fetch('https://api.novu.co/v1/execution-details', {
    method: 'GET',
    
  });
  const data = await response.json();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  // Get execution details
  $novu->getExecutionDetails([
      'notificationId' => '<insert-notification-id>',
      'subscriberId'   => '<insert-subscriber-id>'
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.execution_details({
      'notificationId' => '8fxxx-xxx-ef9xxxxce66',
      'subscriberId' => '7789'
  })
  ```

  ```python Python theme={null}
  from novu.api import ExecutionDetailApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = ExecutionDetailApi(url, api_key).list(
      notification_id = "<The notification ID in Novu>",
      subscriber_id = "<The subscriber ID in Novu>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.executionDetails(query = {});
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "_organizationId": "string",
        "_jobId": "string",
        "_environmentId": "string",
        "_notificationId": "string",
        "_notificationTemplateId": "string",
        "_subscriberId": "string",
        "_messageId": "string",
        "providerId": "string",
        "transactionId": "string",
        "channel": "in_app",
        "detail": "string",
        "source": "Credentials",
        "status": "Success",
        "isTest": true,
        "isRetry": true,
        "createdAt": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Create feed
Source: https://v0.x-docs.novu.co/api-reference/feeds/create-feed

post /v1/feeds

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request POST \
  --url https://api.novu.co/v1/feeds \
  --header 'Authorization: ApiKey <NOVU_API_KEY>' \
  --header 'Content-Type: application/json' \
  --data '{"name": "<FEED_NAME>"}'
  ```

  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.feeds.create("<Feed_Name>");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->createFeed([
      'name' => '<insert-name-for-feed>'
  ]);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.create_feed({
      'name' => 'New feed'
  })
  ```

  ```python Python theme={null}
  from novu.api import FeedApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = FeedApi(url, api_key).create(
      name = "<Feed_Name>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.createFeed(body);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "identifier": "string",
      "_environmentId": "string",
      "_organizationId": "string"
    }
  }
  ```
</ResponseExample>


# Delete feed
Source: https://v0.x-docs.novu.co/api-reference/feeds/delete-feed

delete /v1/feeds/{feedId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request DELETE \
  --url https://api.novu.co/v1/feeds/{FEED_IDENTIFIER} \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.feeds.delete("<Feed_Id>");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->deleteFeed();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.delete_feed("<Feed_Id>")
  ```

  ```python Python theme={null}
  from novu.api import FeedApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = FeedApi(url, api_key).delete(
      Feed_Id = "<ID of the feed to be deleted>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.deleteFeed(Feed_Id);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "name": "string",
        "identifier": "string",
        "_environmentId": "string",
        "_organizationId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Get feeds
Source: https://v0.x-docs.novu.co/api-reference/feeds/get-feeds

get /v1/feeds

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/feeds \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');
  await novu.feeds.get();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->getFeeds()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.feeds()
  ```

  ```python Python theme={null}
  from novu.api import FeedApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = FeedApi(url, api_key).list(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.feeds();
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "name": "string",
        "identifier": "string",
        "_environmentId": "string",
        "_organizationId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Get v1blueprints
Source: https://v0.x-docs.novu.co/api-reference/get-v1blueprints

get /v1/blueprints/{templateId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get v1blueprintsgroup by category
Source: https://v0.x-docs.novu.co/api-reference/get-v1blueprintsgroup-by-category

get /v1/blueprints/group-by-category

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Validate the mx record setup for the inbound parse functionality
Source: https://v0.x-docs.novu.co/api-reference/inbound-parse/validate-the-mx-record-setup-for-the-inbound-parse-functionality

get /v1/inbound-parse/mx/status

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import fetch from 'node-fetch';

  const response = await fetch('https://api.novu.co/v1/inbound-parse/mx/status', {
    method: 'GET',
    
  });
  const data = await response.json();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);


  // Validate MX Record for Inbound Parse
  $novu->validateMXRecordForInboundParse()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.validate_mx_record_setup_for_inbound_parse()
  ```

  ```python Python theme={null}
  from novu.api import InboundParseApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = InboundParseApi(url, api_key).validate_mx_record_setup(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.validateMxRecordSetupForInboundParse();
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
      "mxRecordConfigured": true
    }
  }
  ```
</ResponseExample>


# Create an integration
Source: https://v0.x-docs.novu.co/api-reference/integrations/create-integration

post /v1/integrations
Create an integration for the current environment the user is based on the API key provided. 
    Each provider supports different credentials, check the provider documentation for more details. Only integration metadata is returned, credentials field is returned as an empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --location 'https://api.novu.co/v1/integrations' \
  --header 'Content-Type: application/json' \
  --header 'Accept: application/json' \
  --header 'Authorization: ApiKey <NOVU_API_KEY>' \
  --data '{
      "name": "SES",
      "identifier": "ses-NkIQ5Koy3-123",
      "credentials": {
          "apiKey": "ACCESS_KEY_ID",
          "secretKey": "SECRET_ACCESS_KEY",
          "region": "us-east-2",
          "from": "FROM_EMAIL_ADDRESS",
          "senderName": "SENDER_NAME",
          // ... other credentials as per provider
      },
      "conditions": [],
      "active": true,
      "check": false,
      "providerId": "ses",
      "channel": "email"
  }'
  ```

  ```javascript Node.js theme={null}
  import { Novu, ChannelTypeEnum, ProvidersIdEnum } from '@novu/node';  
  const novu = new Novu('<NOVU_API_KEY>');

  const createPaylod = {
    name: "SendGrid",
    identifier: "sendgrid-identifier",
    credentials: {
      apiKey: "SUPER_SECRET_API_KEY",
      from: "sales@novu.co",
      senderName: "Novu Sales Team",
      channel: ChannelTypeEnum.EMAIL,
      // ... other credentials as per provider
    },
    active: true,
    check: false
  }

  await novu.integrations.create(ProvidersIdEnum.SendGrid, createPayload);
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  // Create integration
  $novu->createIntegration([
      'providerId' => '<insert->provider->id>',
      'channel' => '<insert->channel>',
      'credentials' => [
          // insert all the fields
      ],
      'active' => true,
      'check' => true
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  body = {
      'providerId' => '<insert-provider-id>',
      'channel' => '<insert-channel>',
      'credentials' => {
          # insert all the fields
      },
      'active' => true,
      'check' => true
  }
  client.create_integration(body)
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).create(
      integration="", # Integration instance that you want to create.
      check="", # If you want the Novu server to check his connection using given integration configuration. Defaults to True.

  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.createIntegration(body)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "_environmentId": "string",
      "_organizationId": "string",
      "name": "string",
      "identifier": "string",
      "providerId": "string",
      "channel": "in_app",
      "credentials": {
        "apiKey": "string",
        "user": "string",
        "secretKey": "string",
        "domain": "string",
        "password": "string",
        "host": "string",
        "port": "string",
        "secure": true,
        "region": "string",
        "accountSid": "string",
        "messageProfileId": "string",
        "token": "string",
        "from": "string",
        "senderName": "string",
        "projectName": "string",
        "applicationId": "string",
        "clientId": "string",
        "requireTls": true,
        "ignoreTls": true,
        "tlsOptions": {},
        "baseUrl": "string",
        "webhookUrl": "string",
        "redirectUrl": "string",
        "hmac": true,
        "serviceAccount": "string",
        "ipPoolName": "string"
      },
      "active": true,
      "deleted": true,
      "deletedAt": "string",
      "deletedBy": "string",
      "primary": true
    }
  }
  ```
</ResponseExample>


# Delete an integration
Source: https://v0.x-docs.novu.co/api-reference/integrations/delete-integration

delete /v1/integrations/{integrationId}
Delete an integration by its unique key identifier **integrationId**. 
    This action is irreversible. Only integration metadata is returned, credentials field is returned as empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';  

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.integrations.delete("integrationId");
  ```

  ```php PHP theme={null}
  // Get integrations
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');
  $novu->deleteIntegration($integrationId);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.delete_integration('<insert-provider-id>')
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).delete(
      integration_id="<The integration ID>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.deleteIntegration(integrationId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "name": "string",
        "identifier": "string",
        "providerId": "string",
        "channel": "in_app",
        "credentials": {
          "apiKey": "string",
          "user": "string",
          "secretKey": "string",
          "domain": "string",
          "password": "string",
          "host": "string",
          "port": "string",
          "secure": true,
          "region": "string",
          "accountSid": "string",
          "messageProfileId": "string",
          "token": "string",
          "from": "string",
          "senderName": "string",
          "projectName": "string",
          "applicationId": "string",
          "clientId": "string",
          "requireTls": true,
          "ignoreTls": true,
          "tlsOptions": {},
          "baseUrl": "string",
          "webhookUrl": "string",
          "redirectUrl": "string",
          "hmac": true,
          "serviceAccount": "string",
          "ipPoolName": "string"
        },
        "active": true,
        "deleted": true,
        "deletedAt": "string",
        "deletedBy": "string",
        "primary": true
      }
    ]
  }
  ```
</ResponseExample>


# List active integrations
Source: https://v0.x-docs.novu.co/api-reference/integrations/get-active-integrations

get /v1/integrations/active
List all the active integrations created in the organization. Only integration metadata is returned, credentials field is returned as an empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node'; 

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.integrations.getActive();
  ```

  ```php PHP theme={null}
  // Get integrations
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getActiveIntegrations()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.active_integrations()
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).list(
      only_active=true # This allows one to retrieve only active integrations. Defaults to False.
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.activeIntegrations()
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```
  {
      _id: "_id",
      _environmentId: "_environmentId",
      _organizationId: "_organizationId",
      name: "name",
      identifier: "identifier",
      providerId: "providerId",
      channel: "channel",
      credentials: credentials,
      active: true,
      deleted: true,
      deletedAt: "deletedAt",
      deletedBy: "deletedBy",
      primary: true
  }
  ```
</ResponseExample>


# List all integrations
Source: https://v0.x-docs.novu.co/api-reference/integrations/get-integrations

get /v1/integrations
List all the channels integrations created in the organization. Only integration metadata is returned, credentials field is returned as an empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';  

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.integrations.getAll();
  ```

  ```php PHP theme={null}
  // Get integrations
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getIntegrations()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.integrations()
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
      // get integrations
  	integrations, err := novuClient.IntegrationsApi.GetAll(ctx)
  	if err != nil {
  		log.Fatal("Get all integrations error: ", err.Error())
  	}
  	fmt.Println(integrations)
  }
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).list(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.integrations()
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      _id: "_id",
      _environmentId: "_environmentId",
      _organizationId: "_organizationId",
      name: "name",
      identifier: "identifier",
      providerId: "providerId",
      channel: "channel",
      credentials: credentials,
      active: true,
      deleted: true,
      deletedAt: "deletedAt",
      deletedBy: "deletedBy",
      primary: true
  }
  ```
</ResponseExample>


# Get webhook support status for provider
Source: https://v0.x-docs.novu.co/api-reference/integrations/get-webhook-support-status-for-provider

get /v1/integrations/webhook/provider/{providerId}/status

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu, ProvidersIdEnum } from '@novu/node';  

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.integrations.getWebhookProviderStatus(ProvidersIdEnum.SendGrid);
  ```

  ```php PHP theme={null}
  // Get integrations
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getWebhookSupportStatusForProvider($providerId)->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.webhook_provider_status('<insert-provider-id>')
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).status(
      provider_id="<The_Provider_ID>", # Get webhook support status for a given provider using its providerID.
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.webhookProviderStatus(providerId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      200: "The status of the webhook for the provider requested"
  }
  ```
</ResponseExample>


# Update integration as primary
Source: https://v0.x-docs.novu.co/api-reference/integrations/set-integration-as-primary

post /v1/integrations/{integrationId}/set-primary
Update an integration as **primary** by its unique key identifier **integrationId**. 
    This API will set the integration as primary for that channel in the current environment. 
    Primary integration is used to deliver notification for sms and email channels in the workflow. 
    Only integration metadata is returned, credentials field is returned as an empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';  

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.integrations.setIntegrationAsPrimary("integrationId")
  ```

  ```php PHP theme={null}
  <?php

  $url = 'https://api.novu.co/v1/integrations/:integrationId/set-primary';
  $data = array(
    [options]
  );
  $options = array(
    "http" => array(
    "header"  => "Content-type: application/json",
    "header"  => "Authorization: ApiKey REPLACE_WITH_API_KEY",
    "method"  => "POST",
    "content" => json_encode($data)
    )
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);

  if ($result === FALSE) { /* Handle error */ }

  echo $result;
      
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'uri'

  uri = URI.parse('https://api.novu.co/v1/integrations/:integrationId/set-primary')
  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri)

  request.body = '{
    [options]
  }'
  request.content_type = 'application/json'
  request.add_field('Authorization', 'ApiKey REPLACE_WITH_API_KEY')


  response = http.request(request)

  puts response.body
      
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/integrations/:integrationId/set-primary"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
  ```

  ```python Python theme={null}
  import requests

  response = requests.post('https://api.novu.co/v1/integrations/:integrationId/set-primary')

  print(response.json())
      
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "_id": "string",
    "_environmentId": "string",
    "_organizationId": "string",
    "name": "string",
    "identifier": "string",
    "providerId": "string",
    "channel": "in_app",
    "credentials": {
      "apiKey": "string",
      "user": "string",
      "secretKey": "string",
      "domain": "string",
      "password": "string",
      "host": "string",
      "port": "string",
      "secure": true,
      "region": "string",
      "accountSid": "string",
      "messageProfileId": "string",
      "token": "string",
      "from": "string",
      "senderName": "string",
      "projectName": "string",
      "applicationId": "string",
      "clientId": "string",
      "requireTls": true,
      "ignoreTls": true,
      "tlsOptions": {},
      "baseUrl": "string",
      "webhookUrl": "string",
      "redirectUrl": "string",
      "hmac": true,
      "serviceAccount": "string",
      "ipPoolName": "string"
    },
    "active": true,
    "deleted": true,
    "deletedAt": "string",
    "deletedBy": "string",
    "primary": true
  }
  ```
</ResponseExample>


# Update an integration
Source: https://v0.x-docs.novu.co/api-reference/integrations/update-integration

put /v1/integrations/{integrationId}
Update an integration by its unique key identifier **integrationId**. 
    Each provider supports different credentials, check the provider documentation for more details. Only integration metadata is returned, credentials field is returned as an empty object.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu, ProvidersIdEnum } from '@novu/node'; 

  const novu = new Novu('<NOVU_API_KEY>');

  const updatePayload = {
    name: "SendGrid",
    identifier: "sendgrid-identifier",
    credentials: {
      apiKey: "SUPER_SECRET_API_KEY",
      from: "no-reply@novu.co",
      senderName: "Novu Team"
      // ... other credentials as per provider
    },
    active: true,
    check: false
  }

  await novu.integrations.getWebhookProviderStatus(ProvidersIdEnum.SendGrid, updatePayload);
  ```

  ```php PHP theme={null}
  // Get integrations
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->updateIntegration($integrationId, [
      'active' => true,
      'credentials' => [
          // insert all the fields
      ],
      'check' => true
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  body = {
      'active' => true,
      'check' => true
      'credentials' => {
          # insert all the fields
      },
  }
  client.update_integration('<insert-provider-id>', body)
  ```

  ```python Python theme={null}
  from novu.api import IntegrationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = IntegrationApi(url, api_key).update(
      integration="<The instance of the integration to update>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.updateIntegration(integrationId, body);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "_environmentId": "string",
      "_organizationId": "string",
      "name": "string",
      "identifier": "string",
      "providerId": "string",
      "channel": "in_app",
      "credentials": {
        "apiKey": "string",
        "user": "string",
        "secretKey": "string",
        "domain": "string",
        "password": "string",
        "host": "string",
        "port": "string",
        "secure": true,
        "region": "string",
        "accountSid": "string",
        "messageProfileId": "string",
        "token": "string",
        "from": "string",
        "senderName": "string",
        "projectName": "string",
        "applicationId": "string",
        "clientId": "string",
        "requireTls": true,
        "ignoreTls": true,
        "tlsOptions": {},
        "baseUrl": "string",
        "webhookUrl": "string",
        "redirectUrl": "string",
        "hmac": true,
        "serviceAccount": "string",
        "ipPoolName": "string"
      },
      "active": true,
      "deleted": true,
      "deletedAt": "string",
      "deletedBy": "string",
      "primary": true
    }
  }
  ```
</ResponseExample>


# Delete layout
Source: https://v0.x-docs.novu.co/api-reference/layouts/delete-layout

delete /v1/layouts/{layoutId}
Execute a soft delete of a layout given a certain ID.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.layouts.delete("layoutId");
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.delete_layout('<insert-layout-id>')
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).delete(
      layout_id="<Layout_ID to identify the layout to be deleted>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.deleteLayout(layoutId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      204: "The layout has been deleted correctly",
      404: "The layout with the layoutId provided does not exist in the database so it can not be deleted.",
      409: "Either you are trying to delete a layout that is being used or a layout that is the default in the environment."
  }
  ```
</ResponseExample>


# Filter layouts
Source: https://v0.x-docs.novu.co/api-reference/layouts/filter-layouts

get /v1/layouts
Returns a list of layouts that can be paginated using the `page` query parameter and filtered by the environment where it is executed from the organization the user belongs to.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  const params = {
    page: 0, // optional
    pageSize: 20, // optional
    sortBy: "_id"
    orderBy: -1 //optional
  }

  await novu.layouts.list(params);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.layouts({
      'page' => 1, # optional
      'pageSize' => 10, # optional
      'sortBy' => 'createdAt', # optional
      'orderBy' => 1 # optional
  })
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).list(
      page="<Page number for pagination>",
      limit="Size of each page",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.layouts(query = {});
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      data: ["data"],
      page: 0,
      pageSize: 0,
      totalCount: 0
  }
  ```
</ResponseExample>


# Get layout
Source: https://v0.x-docs.novu.co/api-reference/layouts/get-layout

get /v1/layouts/{layoutId}
Get a layout by its ID

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.layouts.get("layoutId");
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  body = {
      'active' => true,
      'check' => true
      'credentials' => {
          # insert all the fields
      },
  }
  client.layout('<insert-layout-id>')
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).get(
      layout_id="<The layout ID>"
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.layout(layoutId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "_organizationId": "string",
      "_environmentId": "string",
      "_creatorId": "string",
      "name": "string",
      "identifier": "string",
      "description": "string",
      "channel": "in_app",
      "content": "string",
      "contentType": "string",
      "variables": [
        {}
      ],
      "isDefault": true,
      "isDeleted": true,
      "createdAt": "string",
      "updatedAt": "string",
      "_parentId": "string"
    }
  }
  ```
</ResponseExample>


# Layout creation
Source: https://v0.x-docs.novu.co/api-reference/layouts/layout-creation

post /v1/layouts
Create a layout

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  const payload = {
    content: "<h1>Layout Start</h1>{{{body}}}<h1>Layout End</h1>",
    description: "Organisation's first layout",
    name: "First Layout",
    identifier: "firstlayout",
    variables: [
      {
        type: "String",
        name: "body"
        required: true
        defValue: ""
      }
    ]
    isDefault: "false"
  }
  await novu.layouts.create(payload);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  payload = {
      'name' => 'New layout',
      'content' => '{{{body}}}',
      'variables' => ['<list-variables-here>'], # optional
      'description' => 'This is a description for the new layout', # optional
      'isDefault' => true # optional
  }
  client.create_layout(payload)
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).create(
      layout="<The instance of the layout to create>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.createLayout(body);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
      "_id": "Layout identifier"
    }
  }
  ```
</ResponseExample>


# Set default layout
Source: https://v0.x-docs.novu.co/api-reference/layouts/set-default-layout

post /v1/layouts/{layoutId}/default
Sets the default layout for the environment and updates to non default to the existing default layout (if any).

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.layouts.setDefault("layoutId");
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.make_default_layout('<insert-layout-id>')
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).set_default(
      layout_id= "<The layout_id corresponding to the layout to be set default>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.makeDefaultLayout(layoutId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      204: "The selected layout has been set as the default for the environment."

      404: "The layout with the layoutId provided does not exist in the database so it can not be set as the default for the environment."
  }
  ```
</ResponseExample>


# Update a layout
Source: https://v0.x-docs.novu.co/api-reference/layouts/update-a-layout

patch /v1/layouts/{layoutId}
Update the name, content and variables of a layout. Also change it to be default or no.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  const payloadToUpdate = {
    content: "<h1>Layout Start</h1>{{{body}}}<h1>Layout End</h1>",
    description: "Organisation's first layout",
    name: "First Layout",
    identifier: "firstlayout",
    variables: [
      {
        type: "String",
        name: "body"
        required: true
        defValue: ""
      }
    ]
    isDefault: false
  }
  await novu.layouts.update("layoutId", payloadToUpdate);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  payload = {
      'name' => 'Update layout', # optional
      'content' => '{{{body}}}', # optional
      'description' => 'This is a description for the new layout', # optional
      'isDefault' => true # optional
      'variables' => ['<list-variables-here>'], # optional
  }
  client.update_layout('<insert-layout-id>', payload)
  ```

  ```python Python theme={null}
  from novu.api import LayoutApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = LayoutApi(url, api_key).patch(
      layout= "<The instance of the layout to be updated>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.updateLayout(layoutId, body);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "name": "string",
    "identifier": "string",
    "description": "string",
    "content": "string",
    "variables": [
      {}
    ],
    "isDefault": true
  }
  ```
</ResponseExample>


# Delete a message
Source: https://v0.x-docs.novu.co/api-reference/messages/delete-message

delete /v1/messages/{messageId}
Delete a message entity from the Novu platform by **messageId**. 
    This action is irreversible. **messageId** is required and of mongodbId type.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu, ChannelTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.messages.deleteById("<Message_Id>");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu("<NOVU_API_KEY>");

  $novu->deleteMessage();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.delete_message('<insert-message-id>')
  ```

  ```python Python theme={null}
  from novu.api import MessageApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = MessageApi(url, api_key).delete(
      message_id= "The message ID to delete",    
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.deleteMessage(messageId);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "acknowledged": true,
      "status": "deleted"
    }
  }
  ```
</ResponseExample>


# Delete messages by transactionId
Source: https://v0.x-docs.novu.co/api-reference/messages/delete-message-by-transactionid

delete /v1/messages/transaction/{transactionId}
Delete multiple messages from the Novu platform using **transactionId** of triggered event. 
    This API supports filtering by **channel** and delete all messages associated with the **transactionId**.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```cURL theme={null}
  curl --request DELETE \
  --url 'https://api.novu.co/v1/messages/transaction/{transactionId}' \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```
</RequestExample>

<ResponseExample>
  ```json theme={null}
  204 - No Content
  ```
</ResponseExample>


# List all messages
Source: https://v0.x-docs.novu.co/api-reference/messages/get-messages

get /v1/messages
List all messages for the current environment. 
    This API supports filtering by **channel**, **subscriberId**, and **transactionId**. 
    This API returns a paginated list of messages.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu, ChannelTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  const params = {
    page: 0, // optional
    limit: 20, // optional
    subscriberId: "subscriberId"  //optional
    channel: ChannelTypeEnum.EMAIL //optional
    transactionIds : ["txnId1","txnId2"] //optional
  }

  await novu.messages.list(params);
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu("<NOVU_API_KEY>");

  $novu->getMessages();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'channel' => 'slack', # optional
      'subscriberId' => '7789', # optional
      'transactionId' =>'sw900999as', # optional
      'page' => 4, # optional
      'limit' => 10, # optional
  }
  client.messages(payload)
  ```

  ```python Python theme={null}
  from novu.api import MessageApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = MessageApi(url, api_key).list(
      limit= "The number of messages to fetch, defaults to 10",
      page= "The page to fetch, defaults to 0",
      channel = "The channel for the messages you wish to list. Defaults to None.",
      subscriber_id = "The subscriberId for the subscriber you like to list messages for",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.messages(query = {});
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      hasMore: true,
      data: [data],
      pageSize: 0,
      page: 0
  }
  ```
</ResponseExample>


# Retrieve an event
Source: https://v0.x-docs.novu.co/api-reference/notification/get-notification

get /v1/notifications/{notificationId}
Retrieve an event by its unique key identifier **notificationId**. 
    Here **notificationId** is of mongodbId type. 
    This API returns the event details - execution logs, status, actual notification (message) generated by each workflow step.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.notification

  fun main() {
      val novu = Novu(apiKey = "<NOVU_API_KEY>")
      val notification = novu.notification("<NOTIFICATION_ID>")
      println(notification)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notifications/{notificationId} \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```python Python theme={null}
  from novu.api import NotificationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  notificationApi = NotificationApi(url, api_key)

  notification = notificationApi.get("<notificationId>")
  print(notification)
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $notification = $novu->getNotification($notificationId)-toArray();
  ```
</RequestExample>


# Get notification graph statistics
Source: https://v0.x-docs.novu.co/api-reference/notification/get-notification-graph-statistics

get /v1/notifications/graph/stats

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notifications/graph/stats \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```python Python theme={null}
  from novu.api import NotificationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  notificationApi = NotificationApi(url, api_key)

  graphStats = notificationApi.graph_stats()
  list(graphStats)
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $notificationGraphStats = $novu->getNotificationGraphStats()->toArray();
  ```
</RequestExample>


# Get notification statistics
Source: https://v0.x-docs.novu.co/api-reference/notification/get-notification-statistics

get /v1/notifications/stats

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.notificationsStats

  fun main() {
      val novu = Novu(apiKey = "<NOVU_API_KEY>")
      val notificationsStats = novu.notificationsStats()
      println(notificationsStats)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notifications/stats \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```python Python theme={null}
  from novu.api import NotificationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  notificationApi = NotificationApi(url, api_key)

  notification_stats = notificationApi.stats()
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $notificationStats = $novu->getNotificationStats()->toArray();
  ```
</RequestExample>


# List all events
Source: https://v0.x-docs.novu.co/api-reference/notification/get-notifications

get /v1/notifications
List all notification events (triggered events) for the current environment. 
    This API supports filtering by **channels**, **templates**, **emails**, **subscriberIds**, **transactionId**, **topicKey**, **severity**, **contextKeys**. 
    Checkout all available filters in the query section.
    This API returns event triggers, to list each channel notifications, check messages APIs.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.dto.request.NotificationRequest
  import co.novu.extensions.notifications

  fun main() {
      val novu = Novu(apiKey = "<NOVU_API_KEY>")
      val notificationRequest = NotificationRequest("<CHANNELS>", "<TEMPLATES>", "<EMAILS>", "<SEARCH>");
      val notifications = novu.notifications(notificationRequest)
      println(notifications)
  }
  ```

  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notifications \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```python Python theme={null}
  from novu.api import NotificationApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  notificationApi = NotificationApi(url, api_key)

  notifications = notificationApi.list()
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu('<NOVU_API_KEY>');

  $notifications = $novu->getNotifications()->toArray();
  ```
</RequestExample>


# Create an organization
Source: https://v0.x-docs.novu.co/api-reference/organizations/create-organization

post /v1/organizations

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Remove a member from organization using memberId
Source: https://v0.x-docs.novu.co/api-reference/organizations/delete-member-from-organization

delete /v1/organizations/members/{memberId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Fetch all members of current organizations
Source: https://v0.x-docs.novu.co/api-reference/organizations/get-all-members-of-current-organization

get /v1/organizations/members

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Fetch all organizations
Source: https://v0.x-docs.novu.co/api-reference/organizations/get-all-organizations

get /v1/organizations

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Fetch current organization details
Source: https://v0.x-docs.novu.co/api-reference/organizations/get-current-organization

get /v1/organizations/me

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Rename organization name
Source: https://v0.x-docs.novu.co/api-reference/organizations/rename-organization

patch /v1/organizations

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update member role to admin
Source: https://v0.x-docs.novu.co/api-reference/organizations/update-member-role-to-admin

put /v1/organizations/members/{memberId}/roles

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update organization branding details
Source: https://v0.x-docs.novu.co/api-reference/organizations/update-organization-branding

put /v1/organizations/branding

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Create tenant
Source: https://v0.x-docs.novu.co/api-reference/tenants/create-tenant

post /v1/tenants
Create tenant under the current environment

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Delete tenant
Source: https://v0.x-docs.novu.co/api-reference/tenants/delete-tenant

delete /v1/tenants/{identifier}
Deletes a tenant entity from the Novu platform

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get tenant
Source: https://v0.x-docs.novu.co/api-reference/tenants/get-tenant

get /v1/tenants/{identifier}
Get tenant by your internal id used to identify the tenant

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get tenants
Source: https://v0.x-docs.novu.co/api-reference/tenants/get-tenants

get /v1/tenants
Returns a list of tenants, could paginated using the `page` and `limit` query parameter

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update tenant
Source: https://v0.x-docs.novu.co/api-reference/tenants/update-tenant

patch /v1/tenants/{identifier}
Update tenant by your internal id used to identify the tenant

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Check topic subscriber
Source: https://v0.x-docs.novu.co/api-reference/topics/check-topic-subscriber

get /v1/topics/{topicKey}/subscribers/{externalSubscriberId}
Check if a subscriber belongs to a certain topic

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Delete topic
Source: https://v0.x-docs.novu.co/api-reference/topics/delete-topic

delete /v1/topics/{topicKey}
Delete a topic by its topic key if it has no subscribers

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get topic
Source: https://v0.x-docs.novu.co/api-reference/topics/get-topic

get /v1/topics/{topicKey}
Get a topic by its topic key

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Rename a topic
Source: https://v0.x-docs.novu.co/api-reference/topics/rename-a-topic

patch /v1/topics/{topicKey}
Rename a topic by providing a new name

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Subscribers addition
Source: https://v0.x-docs.novu.co/api-reference/topics/subscribers-addition

post /v1/topics/{topicKey}/subscribers
Add subscribers to a topic by key

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Subscribers removal
Source: https://v0.x-docs.novu.co/api-reference/topics/subscribers-removal

post /v1/topics/{topicKey}/subscribers/removal
Remove subscribers from a topic

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Create workflow group
Source: https://v0.x-docs.novu.co/api-reference/workflow-groups/create-workflow-group

post /v1/notification-groups
workflow group was previously named notification group

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request POST \
  --url https://api.novu.co/v1/notification-groups \
  --header 'Authorization: ApiKey <NOVU_API_KEY>' \
  --header 'Content-Type: application/json' \
  --data '{"name": "insert-name"}'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationGroups.create("Product Updates");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->createNotificationGroup([
      'name' => '<insert-name>'
  ]);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.create_notification_group({
      'name' => '<insert-name>'
  })
  ```

  ```python Python theme={null}
  from novu.api import NotificationGroupApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationGroupApi(url, api_key).create(
      name = "<The name of the notification group>",
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.createWorkflowGroup(body);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/notification-groups"
    data := map[string]string{
      "name": "name"
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "_environmentId": "string",
      "_organizationId": "string",
      "_parentId": "string"
    }
  }
  ```
</ResponseExample>


# Delete workflow group
Source: https://v0.x-docs.novu.co/api-reference/workflow-groups/delete-workflow-group

delete /v1/notification-groups/{id}
workflow group was previously named notification group

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request DELETE \
  --url https://api.novu.co/v1/notification-groups/{id} \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationGroups.delete("notificationGroupId");
  ```

  ```php PHP theme={null}
  <?php

  $url = 'https://api.novu.co/v1/notification-groups/:id';
  $data = array(
    [options]
  );
  $options = array(
    "http" => array(
    "header"  => "Content-type: application/json",
    "header"  => "Authorization: ApiKey REPLACE_WITH_API_KEY",
    "method"  => "DELETE",
    "content" => json_encode($data)
    )
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);

  if ($result === FALSE) { /* Handle error */ }

  echo $result;
      
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'uri'

  uri = URI.parse('https://api.novu.co/v1/notification-groups/:id')
  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri)

  request.body = '{
    [options]
  }'
  request.content_type = 'application/json'
  request.add_field('Authorization', 'ApiKey REPLACE_WITH_API_KEY')


  response = http.request(request)

  puts response.body
      
  ```

  ```python Python theme={null}
  import requests

  response = requests.delete('https://api.novu.co/v1/notification-groups/:id')

  print(response.json())
      
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/notification-groups/:id"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("DELETE", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "acknowledged": true,
      "status": "deleted"
    }
  }
  ```
</ResponseExample>


# Get workflow group
Source: https://v0.x-docs.novu.co/api-reference/workflow-groups/get-workflow-group

get /v1/notification-groups/{id}
workflow group was previously named notification group

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notification-groups/{id} \
  --header 'Authorization: ApiKey <NOVU_API_KEY>'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationGroups.getOne("notificationGroupId");
  ```

  ```php PHP theme={null}
  <?php

  $url = 'https://api.novu.co/v1/notification-groups/:id';
  $data = array(
    [options]
  );
  $options = array(
    "http" => array(
    "header"  => "Content-type: application/json",
    "header"  => "Authorization: ApiKey REPLACE_WITH_API_KEY",
    "method"  => "GET",
    "content" => json_encode($data)
    )
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);

  if ($result === FALSE) { /* Handle error */ }

  echo $result;
      
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'uri'

  uri = URI.parse('https://api.novu.co/v1/notification-groups/:id')
  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri)

  request.body = '{
    [options]
  }'
  request.content_type = 'application/json'
  request.add_field('Authorization', 'ApiKey REPLACE_WITH_API_KEY')


  response = http.request(request)

  puts response.body
      
  ```

  ```python Python theme={null}
  import requests

  response = requests.get('https://api.novu.co/v1/notification-groups/:id')

  print(response.json())
      
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/notification-groups/:id"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("GET", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}

    "data": {
      "_id": "string",
      "name": "string",
      "_environmentId": "string",
      "_organizationId": "string",
      "_parentId": "string"
    }
  }
  ```
</ResponseExample>


# Get workflow groups
Source: https://v0.x-docs.novu.co/api-reference/workflow-groups/get-workflow-groups

get /v1/notification-groups
workflow group was previously named notification group

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request GET \
  --url https://api.novu.co/v1/notification-groups \
  --header 'Authorization: ApiKey <NOVU_API_KEY>' \
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationGroups.get();
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->getNotificationGroups()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.notification_groups()
  ```

  ```python Python theme={null}
  from novu.api import NotificationGroupApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationGroupApi(url, api_key).list(
  )
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.notificationGroups();
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/notification-groups"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("GET", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "_id": "string",
        "name": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_parentId": "string"
      }
    ]
  }
  ```
</ResponseExample>


# Update workflow group
Source: https://v0.x-docs.novu.co/api-reference/workflow-groups/update-workflow-group

patch /v1/notification-groups/{id}
workflow group was previously named notification group

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl --request PATCH \
  --url https://api.novu.co/v1/notification-groups/{id} \
  --header 'Authorization: ApiKey <NOVU_API_KEY>' \
  --header 'Content-Type: application/json' \
  --data '{"name": "insert-new-name"}'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationGroups.update("notificationGroupId", { name: "Changelog Updates"});
  ```

  ```php PHP theme={null}
  <?php

  $url = 'https://api.novu.co/v1/notification-groups/:id';
  $data = array(
    "name": "name"
  );
  $options = array(
    "http" => array(
    "header"  => "Content-type: application/json",
    "header"  => "Authorization: ApiKey REPLACE_WITH_API_KEY",
    "method"  => "PATCH",
    "content" => json_encode($data)
    )
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);

  if ($result === FALSE) { /* Handle error */ }

  echo $result;
      
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'uri'

  uri = URI.parse('https://api.novu.co/v1/notification-groups/:id')
  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri)

  request.body = '{
    "name": "name"
  }'
  request.content_type = 'application/json'
  request.add_field('Authorization', 'ApiKey REPLACE_WITH_API_KEY')


  response = http.request(request)

  puts response.body
      
  ```

  ```python Python theme={null}
  import requests

  response = requests.patch('https://api.novu.co/v1/notification-groups/:id', json={
        "name": "name",
  }, headers={
      'Content-Type': 'application/json'
      'Authorization': 'ApiKey REPLACE_WITH_API_KEY'
  })

  print(response.json())
      
  ```

  ```java Java theme={null}
  import co.novu.sdk.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.updateWorkflowGroup(workflowId, body);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/notification-groups/:id"
    data := map[string]string{
      "name": "name"
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("PATCH", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "_environmentId": "string",
      "_organizationId": "string",
      "_parentId": "string"
    }
  }
  ```
</ResponseExample>


# Create workflow overrides
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/create-workflow-overrides

post /v1/workflow-overrides

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Delete workflow override
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/delete-workflow-override

delete /v1/workflow-overrides/{overrideId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get workflow override
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/get-workflow-override

get /v1/workflow-overrides/workflows/{workflowId}/tenants/{tenantId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get workflow override by id
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/get-workflow-override-by-id

get /v1/workflow-overrides/{overrideId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Get workflow overrides
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/get-workflow-overrides

get /v1/workflow-overrides

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update workflow override
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/update-workflow-override

put /v1/workflow-overrides/workflows/{workflowId}/tenants/{tenantId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Update workflow override by id
Source: https://v0.x-docs.novu.co/api-reference/workflow-overrides/update-workflow-override-by-id

put /v1/workflow-overrides/{overrideId}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>


# Create workflow
Source: https://v0.x-docs.novu.co/api-reference/workflows/create-workflow

post /v1/workflows
Workflow was previously named notification template

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request POST \
    --url https://api.novu.co/v1/workflows \
    --header 'Authorization: <authorization>' \
    --header 'Content-Type: application/json' \
    --data '{
      "name": "<name>",
      "notificationGroupId":"<notificationGroupId>",
      "steps": [{ "steps" }]
    }'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.create({
    name: 'Onboarding Workflow',
    // taking first workflow group id
    notificationGroupId: workflowGroupsData.data[0]._id,
    steps: [
      // Adding one chat step
      {
        active: true,
        shouldStopOnFail: false,
        // UUID is optional.
        uuid: '78ab8c72-46de-49e4-8464-257085960f9e',
        name: 'Chat',
        filters: [
          {
            value: 'AND',
            children: [
              {
                field: '{{chatContent}}',
                value: 'flag',
                operator: 'NOT_IN',
                // 'payload'
                on: FilterPartTypeEnum.PAYLOAD,
              },
            ],
          },
        ],
        template: {
          // 'chat'
          type: StepTypeEnum.CHAT,
          active: true,
          subject: '',
          variables: [
            {
              name: 'chatContent',
              // 'String'
              type: TemplateVariableTypeEnum.STRING,
              required: true,
              "defaultValue": "default message",
            },
          ],
          content: '{{chatContent}}',
          contentType: 'editor',
        },
      },
    ],
    description: 'Onboarding workflow to trigger after user sign up',
    active: true,
    draft: false,
    critical: false,
  });
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->createNotificationTemplate([
    "name" => "name",
    "notificationGroupId" => "notificationGroupId",
    "tags" => ["tags"],
    "description" => "description",
    "steps" => ["steps"],
    "active" => true,
    "draft" => true,
    "critical" => true,
    "preferenceSettings" => preferenceSettings
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  body = {
      'name' => '<insert-name>',
      'notificationGroupId' => 'notificationGroupId',
      'tags' => ['tags'], # optional
      'description' => 'description', # optional
      'steps' => [ # optional
         # insert all fields here
      ], 
      'active' => true, # optional
      'draft' => true, # optional
      'critical' => true, # optional
      'preferenceSettings' => { # optional
         # insert all fields here
      },
      'blueprintId' => 'blueprintId' # optional
  }
  client.create_notification_template(body)
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).create(
      notification_template = "< The notification template form definition>",
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.createWorkflow(body);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows"
    data := map[string]string{
      "name": "name",
      "notificationGroupId": "notificationGroupId",
      "tags": ["tags"],
      "description": "description",
      "steps": ["steps"],
      "active": true,
      "draft": true,
      "critical": true,
      "preferenceSettings": preferenceSettings,
      "blueprintId": "blueprintId",
      "data": data
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.createWorkflow

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.createWorkflow(body)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "description": "string",
      "active": true,
      "draft": true,
      "preferenceSettings": {
        "email": true,
        "sms": true,
        "in_app": true,
        "chat": true,
        "push": true
      },
      "critical": true,
      "tags": [
        "string"
      ],
      "steps": [
        {
          "_id": "string",
          "uuid": "string",
          "name": "string",
          "_templateId": "string",
          "active": true,
          "shouldStopOnFail": true,
          "template": {},
          "filters": [
            {
              "isNegated": true,
              "type": "BOOLEAN",
              "value": "AND",
              "children": [
                {
                  "field": "string",
                  "value": "string",
                  "operator": "LARGER",
                  "on": "subscriber"
                }
              ]
            }
          ],
          "_parentId": {},
          "metadata": {
            "amount": 0,
            "unit": "seconds",
            "digestKey": "string",
            "type": "regular",
            "backoff": true,
            "backoffAmount": 0,
            "backoffUnit": "seconds",
            "updateMode": true
          },
          "replyCallback": {}
        }
      ],
      "_organizationId": "string",
      "_creatorId": "string",
      "_environmentId": "string",
      "triggers": [
        {
          "type": "string",
          "identifier": "string",
          "variables": [
            {
              "name": "string"
            }
          ],
          "subscriberVariables": [
            {
              "name": "string"
            }
          ]
        }
      ],
      "_notificationGroupId": "string",
      "_parentId": "string",
      "deleted": true,
      "deletedAt": "string",
      "deletedBy": "string",
      "notificationGroup": {
        "_id": "string",
        "name": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_parentId": "string"
      },
      "data": {},
      "workflowIntegrationStatus": {}
    }
  }
  ```
</ResponseExample>


# Delete workflow
Source: https://v0.x-docs.novu.co/api-reference/workflows/delete-workflow

delete /v1/workflows/{workflowId}
Workflow was previously named notification template

***

## openapi: post /v1/workflows

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request DELETE \
    --url https://api.novu.co/v1/workflows/{workflowId} \
    --header 'Authorization: <authorization>' \
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.delete("workflowId");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->deleteNotificationTemplate($templateId);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.delete_notification_template('<insert-template-id>')
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).delete(
      notification_template_id="<The notification workflow ID of the workflow to be deleted >"
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.deleteWorkflow(workflowId);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows/:workflowId"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("DELETE", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.deleteWorkflow

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.deleteWorkflow(workflowId)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": true
  }
  ```
</ResponseExample>


# Get workflow
Source: https://v0.x-docs.novu.co/api-reference/workflows/get-workflow

get /v1/workflows/{workflowIdOrIdentifier}

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request GET \
    --url https://api.novu.co/v1/workflows/{workflowIdOrIdentifier} \
    --header 'Authorization: <authorization>'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.getOne("workflowIdOrIdentifier");
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getANotificationTemplate($templateId);
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')
  client.notification_template('<insert-template-id>')
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).get(
      notification_template_id = "< The ID of the notification template>",
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.getWorkflow(workflowId);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("GET", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.getWorkflow

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.getWorkflow(workflowId)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "preferenceSettings": {
              "email": true,
              "sms": true,
              "in_app": true,
              "chat": true,
              "push": true
          },
          "_id": "7u83d3123t3a9e261ba9934r8",
          "name": "chat with Discord",
          "active": true,
          "draft": false,
          "critical": true,
          "isBlueprint": false,
          "_notificationGroupId": "641eddefda8256b93f750e0b",
          "tags": [],
          "triggers": [
              {
                  "type": "event",
                  "identifier": "chat-with-discord",
                  "variables": [
                      {
                          "name": "chatMsg",
                          "type": "String",
                          "_id": "7u83d3123t3a9e261ba9934r8",
                          "id": "7u83d3123t3a9e261ba9934r8"
                      }
                  ],
                  "reservedVariables": [],
                  "subscriberVariables": [],
                  "_id": "7u83d3123t3a9e261ba9934r8",
                  "id": "7u83d3123t3a9e261ba9934r8"
              }
          ],
          "steps": [
              {
                  "metadata": {
                      "timed": {
                          "weekDays": [],
                          "monthDays": []
                      }
                  },
                  "active": true,
                  "shouldStopOnFail": false,
                  "uuid": "9799f1c9-0de2-4252-8921-01840a71a741",
                  "name": "Chat",
                  "filters": [
                      {
                          "children": [],
                          "_id": "7u83d3123t3a9e261ba99376e",
                          "id": "7u83d3123t3a9e261ba993999"
                      }
                  ],
                  "_templateId": "6533d389306c4d8cf7853557",
                  "_parentId": null,
                  "_id": "99u3d3123t3a9e261ba993r45",
                  "id": "90uid3123t3a9e261ba9978yu",
                  "template": {
                      "_id": "r567d3123t3a9e261ba9990as",
                      "type": "chat",
                      "active": true,
                      "subject": "",
                      "variables": [
                          {
                              "name": "chatMsg",
                              "type": "String",
                              "required": false,
                              "_id": "2383d3123t3a9e261ba997878",
                              "id": "8711d389306c4d8cf7859090"
                          }
                      ],
                      "content": "{{chatMsg}}",
                      "contentType": "editor",
                      "_environmentId": "234edtyuda8256b93f7567f90",
                      "_organizationId": "333tydefda8256b93f753yh6",
                      "_creatorId": "63123ee5d9af70da9f6a2e4",
                      "_feedId": null,
                      "_layoutId": null,
                      "deleted": false,
                      "createdAt": "2023-10-21T13:35:05.825Z",
                      "updatedAt": "2023-10-21T13:35:18.156Z",
                      "__v": 0,
                      "id": "7u83d3123t3a9e261ba9934r8"
                  }
              }
          ],
          "_environmentId": "234edtyuda8256b93f7567f90",
          "_organizationId": "333tydefda8256b93f753yh6",
          "_creatorId": "63123ee5d9af70da9f6a2e4",
          "deleted": false,
          "createdAt": "2023-10-21T13:34:48.130Z",
          "updatedAt": "2023-10-21T13:35:18.994Z",
          "__v": 0,
          "id": "7u83d3123t3a9e261ba9934r8"
      }
  }
  ```
</ResponseExample>


# Get workflows
Source: https://v0.x-docs.novu.co/api-reference/workflows/get-workflows

get /v1/workflows
Workflows were previously named notification templates

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request GET \
    --url https://api.novu.co/v1/workflows \
    --header 'Authorization: <authorization>'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.getAll({
    page: 0, // optional
    limit: 20 // optional
  });
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);
  $novu->getNotificationTemplates()->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.notification_templates({
      'page' => 4, # optional
      'limit' => 10, # optional
  })
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).list(
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.getWorkflows(page, limit);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows"
    data := map[string]string{
      [options]
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("GET", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.getWorkflows

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.getWorkflows(page, limit)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "page": 0,
      "data": [
          {
              "_id": "64f07ea63f28d769494bd74a",
              "name": "Chat with Novu",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "sms-docs",
                      "variables": [
                          {
                              "name": "payloadVar",
                              "type": "String",
                              "_id": "64f1df7a97770dc90cf8c951"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "64f07ea63f28d769494bd74b",
                      "reservedVariables": []
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "0c22b8e5-762f-49b3-b686-09edb2275e8d",
                      "name": "Chat",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64f1ddba1dde0257bca4352d"
                          }
                      ],
                      "_templateId": "64f1ddba1dde0257bca4351d",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64f1ddba1dde0257bca4351d",
                      "template": {
                          "_id": "64f1ddba1dde0257bca4351d",
                          "type": "chat"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-08-31T11:51:02.984Z",
              "updatedAt": "2023-09-01T12:56:26.881Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "64f024843f28d7694946d097",
              "name": "in-app workflow",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "in-app-workflow",
                      "variables": [
                          {
                              "name": "messageIdentifier",
                              "type": "String",
                              "_id": "64f02b28dd99c21f1e2d4ac7"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "64f024843f28d7694946d098"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "ba437658-522d-439f-94da-02426b42d616",
                      "name": "In-App",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64f02b1914b8a3ace6186985"
                          }
                      ],
                      "_templateId": "64f02b1914b8a3ace618697a",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64f02b1914b8a3ace618697a",
                      "template": {
                          "_id": "64f02b1914b8a3ace618697a",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-08-31T05:26:28.637Z",
              "updatedAt": "2023-08-31T05:54:48.445Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "64eec9583cd25fad61223897",
              "name": "Discord chat demo",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "discord-chat-demo",
                      "variables": [
                          {
                              "name": "chatMsg",
                              "type": "String",
                              "_id": "64eed56c735c8d00d98d2a71"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "64eec9583cd25fad61223898"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "03bb2304-d18c-4dc1-ae5a-62fe2634e787",
                      "name": "Chat",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64eeca4faed841efdcaf95eb"
                          }
                      ],
                      "_templateId": "64eeca4faed841efdcaf95e2",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64eeca4faed841efdcaf95e2",
                      "template": {
                          "_id": "64eeca4faed841efdcaf95e2",
                          "type": "chat"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-08-30T04:45:12.419Z",
              "updatedAt": "2023-08-30T05:36:44.465Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "64db9511c51d09cdd01ff086",
              "name": "testing from browser",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "testing-from-browser",
                      "variables": [],
                      "subscriberVariables": [],
                      "_id": "64db9511c51d09cdd01ff087"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "29a67140-4694-443b-b4e1-8111b399198a",
                      "name": "testting browser",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64db954a98ca413e3d6838a7"
                          }
                      ],
                      "_templateId": "64db954a98ca413e3d68389d",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64db954a98ca413e3d68389d",
                      "template": {
                          "_id": "64db954a98ca413e3d68389d",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-08-15T15:09:05.828Z",
              "updatedAt": "2023-08-25T11:55:48.583Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "64c0e3b9ec5b16b5d790d55a",
              "name": "headless-demo",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "headless-demo",
                      "variables": [
                          {
                              "name": "description",
                              "type": "String",
                              "_id": "64c0e3d2ec5b16b5d790d5f6"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "64c0e3b9ec5b16b5d790d55b"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "e0ba19d2-7833-4525-971c-4f40dd47e2ff",
                      "name": "In-App",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64c0e3d2ec5b16b5d790d5f5"
                          }
                      ],
                      "_templateId": "64c0e3d2ec5b16b5d790d5ea",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64c0e3d2ec5b16b5d790d5ea",
                      "template": {
                          "_id": "64c0e3d2ec5b16b5d790d5ea",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-07-26T09:13:29.090Z",
              "updatedAt": "2023-07-26T09:13:54.856Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "64a41ffee2134f0077e0d222",
              "name": "emailDigestWorkflow",
              "active": true,
              "draft": false,
              "critical": false,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "emaildigestworkflow",
                      "variables": [],
                      "subscriberVariables": [
                          {
                              "name": "email",
                              "_id": "64b8f8c024a8ba51900fece6"
                          }
                      ],
                      "_id": "64a41ffee2134f0077e0d223"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "13b27589-a7ad-47e3-b10d-a1085dd3687d",
                      "name": "Digest",
                      "filters": [],
                      "_templateId": "64a421ae5f8a9af84368c9fe",
                      "_parentId": null,
                      "metadata": {
                          "amount": 20,
                          "unit": "seconds",
                          "type": "regular",
                          "backoffAmount": null,
                          "backoff": false,
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64a421ae5f8a9af84368c9fe",
                      "template": {
                          "_id": "64a421ae5f8a9af84368c9fe",
                          "type": "digest"
                      }
                  },
                  {
                      "active": true,
                      "replyCallback": {
                          "active": false
                      },
                      "shouldStopOnFail": false,
                      "uuid": "4e1d8ebb-355c-4224-8a79-fcbc3c0233a1",
                      "name": "Email",
                      "filters": [
                          {
                              "children": [],
                              "_id": "64a420215f8a9af84368b6b8"
                          }
                      ],
                      "_templateId": "64a420215f8a9af84368b6a6",
                      "_parentId": "64a421ae5f8a9af84368c9fe",
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "64a420215f8a9af84368b6a6",
                      "template": {
                          "_id": "64a420215f8a9af84368b6a6",
                          "type": "email"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-07-04T13:34:54.781Z",
              "updatedAt": "2023-07-20T09:05:04.701Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "6492d92f616db8f05a982022",
              "name": "digest showcase",
              "active": true,
              "draft": false,
              "critical": true,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "digest-showcase",
                      "variables": [],
                      "subscriberVariables": [],
                      "_id": "6492d92f616db8f05a982023"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "556f0514-01b6-46f9-9e3d-72a4c060af54",
                      "name": "Digest",
                      "filters": [],
                      "_templateId": "6492d9735da9bfaf640771a2",
                      "_parentId": null,
                      "metadata": {
                          "amount": 10,
                          "unit": "seconds",
                          "type": "regular",
                          "backoffAmount": null,
                          "backoff": false,
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "6492d9735da9bfaf640771a2",
                      "template": {
                          "_id": "6492d9735da9bfaf640771a2",
                          "type": "digest"
                      }
                  },
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "024a27f4-82da-485c-b4a7-bea05c2631e3",
                      "name": "In-App",
                      "filters": [
                          {
                              "children": [],
                              "_id": "6492d9735da9bfaf640771b6"
                          }
                      ],
                      "_templateId": "6492d9735da9bfaf640771aa",
                      "_parentId": "6492d9735da9bfaf640771a2",
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "6492d9735da9bfaf640771aa",
                      "template": {
                          "_id": "6492d9735da9bfaf640771aa",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-06-21T11:04:15.546Z",
              "updatedAt": "2023-07-19T13:32:18.474Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "6471aa6f3a4ec8a599669991",
              "name": "quickstart",
              "active": true,
              "draft": false,
              "critical": false,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "quickstart",
                      "variables": [
                          {
                              "name": "description",
                              "type": "String",
                              "_id": "6471aaa08b0b51ed173ba8fd"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "6471aa6f3a4ec8a599669992"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "982bf6a1-6f0c-46c6-a8ad-6daa67f327e2",
                      "name": "In-App",
                      "filters": [
                          {
                              "children": [],
                              "_id": "6471aa85720b54f89ed97de3"
                          }
                      ],
                      "_templateId": "6471aa85720b54f89ed97dd8",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "6471aa85720b54f89ed97dd8",
                      "template": {
                          "_id": "6471aa85720b54f89ed97dd8",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-05-27T06:59:59.254Z",
              "updatedAt": "2023-05-27T07:00:48.618Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "6469fc87301d88d6d2b74741",
              "name": "Email quickstart",
              "active": true,
              "draft": false,
              "critical": false,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "email-quickstart",
                      "variables": [
                          {
                              "name": "email",
                              "type": "String",
                              "_id": "646a031c25b1fb30f274ac35"
                          },
                          {
                              "name": "description",
                              "type": "String",
                              "_id": "646a031c25b1fb30f274ac36"
                          }
                      ],
                      "subscriberVariables": [
                          {
                              "name": "email",
                              "_id": "646a031c25b1fb30f274ac34"
                          }
                      ],
                      "_id": "6469fc87301d88d6d2b74742"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "replyCallback": {
                          "active": false
                      },
                      "shouldStopOnFail": false,
                      "uuid": "3b512084-6cba-400c-8644-d9e9bff6bbfc",
                      "name": "Email",
                      "filters": [
                          {
                              "children": [],
                              "_id": "6469fd9bc2c5b74546b2cc80"
                          }
                      ],
                      "_templateId": "6469fd9bc2c5b74546b2cc76",
                      "_parentId": null,
                      "metadata": {
                          "timed": {
                              "weekDays": [],
                              "monthDays": []
                          }
                      },
                      "_id": "6469fd9bc2c5b74546b2cc76",
                      "template": {
                          "_id": "6469fd9bc2c5b74546b2cc76",
                          "type": "email"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-05-21T11:12:07.036Z",
              "updatedAt": "2023-05-21T11:40:12.955Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          },
          {
              "_id": "6450b033631887e5f013f0df",
              "name": "notif-genenerator",
              "active": true,
              "draft": false,
              "critical": false,
              "isBlueprint": false,
              "_notificationGroupId": "641eddefda8256b93f750e0b",
              "tags": [],
              "triggers": [
                  {
                      "type": "event",
                      "identifier": "notif-genenerator",
                      "variables": [
                          {
                              "name": "description",
                              "type": "String",
                              "_id": "645a5b18e1a93324256bdf59"
                          }
                      ],
                      "subscriberVariables": [],
                      "_id": "6450b033631887e5f013f0e0"
                  }
              ],
              "steps": [
                  {
                      "active": true,
                      "shouldStopOnFail": false,
                      "uuid": "0486c699-2db4-4868-9ed5-c407acacb728",
                      "name": "In-App",
                      "filters": [
                          {
                              "children": [],
                              "_id": "6450b06e9c851c56f803d489"
                          }
                      ],
                      "_templateId": "6450b06e9c851c56f803d47e",
                      "_parentId": null,
                      "_id": "6450b06e9c851c56f803d47e",
                      "template": {
                          "_id": "6450b06e9c851c56f803d47e",
                          "type": "in_app"
                      }
                  }
              ],
              "preferenceSettings": {
                  "email": true,
                  "sms": true,
                  "in_app": true,
                  "chat": true,
                  "push": true
              },
              "_environmentId": "641eddefda8256b93f750e07",
              "_organizationId": "641eddefda8256b93f750e01",
              "_creatorId": "641eddee5d9af70da9f6a2e4",
              "deleted": false,
              "createdAt": "2023-05-02T06:39:47.699Z",
              "updatedAt": "2023-05-09T14:39:20.811Z",
              "__v": 0,
              "notificationGroup": {
                  "_id": "641eddefda8256b93f750e0b",
                  "name": "General",
                  "_organizationId": "641eddefda8256b93f750e01",
                  "_environmentId": "641eddefda8256b93f750e07",
                  "createdAt": "2023-03-25T11:41:35.279Z",
                  "updatedAt": "2023-03-25T11:41:35.279Z",
                  "__v": 0
              },
              "workflowIntegrationStatus": {
                  "hasActiveIntegrations": true,
                  "channels": {
                      "in_app": {
                          "hasActiveIntegrations": true
                      },
                      "email": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "sms": {
                          "hasActiveIntegrations": true,
                          "hasPrimaryIntegrations": true
                      },
                      "chat": {
                          "hasActiveIntegrations": true
                      },
                      "push": {
                          "hasActiveIntegrations": false
                      }
                  }
              }
          }
      ],
      "totalCount": 20,
      "pageSize": 10
  }
  ```
</ResponseExample>


# Update workflow
Source: https://v0.x-docs.novu.co/api-reference/workflows/update-workflow

put /v1/workflows/{workflowId}
Workflow was previously named notification template

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request PUT \
    --url https://api.novu.co/v1/workflows/{workflowId} \
    --header 'Authorization: <authorization>' \
    --header 'Content-Type: application/json' \
    --data '{
      "name": "<name>",
    }'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.update("workflowId", {
    name: "Send daily digest email update",
    description: "This workflow will send daily digest email to user at 9:00 AM"
    /**
     * all other fields from create workflow payload
     */
  });
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->updateNotificationTemplate($templateId, [
    "name" => "name",
    "tags" => ["tags"],
    "description" => "description",
    "identifier" => "identifier",
    "steps" => ["steps"],
    "notificationGroupId" => "notificationGroupId",
    "active" => true,
    "critical" => true,
    "preferenceSettings" => preferenceSettings
  ])->toArray();
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  body = {
      'name' => '<insert-name>',
      'notificationGroupId' => 'notificationGroupId',
      'tags' => ['tags'], # optional
      'description' => 'description', # optional
      'steps' => [ # optional
         # insert all fields here
      ], 
      'active' => true, # optional
      'draft' => true, # optional
      'critical' => true, # optional
      'preferenceSettings' => { # optional
         # insert all fields here
      },
      'blueprintId' => 'blueprintId' # optional
  }
  client.update_notification_template('<insert-template-id>', body)
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).update(
      notification_template_id = "< The ID of the notification workflow to be updated>",
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.updateWorkflow(workflowId, body);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows/:workflowId"
    data := map[string]string{
      "name": "name",
      "tags": ["tags"],
      "description": "description",
      "identifier": "identifier",
      "steps": ["steps"],
      "notificationGroupId": "notificationGroupId",
      "critical": true,
      "preferenceSettings": preferenceSettings,
      "data": data
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("PUT", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.updateWorkflow

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.updateWorkflow(workflowId, body)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "description": "string",
      "active": true,
      "draft": true,
      "preferenceSettings": {
        "email": true,
        "sms": true,
        "in_app": true,
        "chat": true,
        "push": true
      },
      "critical": true,
      "tags": [
        "string"
      ],
      "steps": [
        {
          "_id": "string",
          "uuid": "string",
          "name": "string",
          "_templateId": "string",
          "active": true,
          "shouldStopOnFail": true,
          "template": {},
          "filters": [
            {
              "isNegated": true,
              "type": "BOOLEAN",
              "value": "AND",
              "children": [
                {
                  "field": "string",
                  "value": "string",
                  "operator": "LARGER",
                  "on": "subscriber"
                }
              ]
            }
          ],
          "_parentId": {},
          "metadata": {
            "amount": 0,
            "unit": "seconds",
            "digestKey": "string",
            "type": "regular",
            "backoff": true,
            "backoffAmount": 0,
            "backoffUnit": "seconds",
            "updateMode": true
          },
          "replyCallback": {}
        }
      ],
      "_organizationId": "string",
      "_creatorId": "string",
      "_environmentId": "string",
      "triggers": [
        {
          "type": "string",
          "identifier": "string",
          "variables": [
            {
              "name": "string"
            }
          ],
          "subscriberVariables": [
            {
              "name": "string"
            }
          ]
        }
      ],
      "_notificationGroupId": "string",
      "_parentId": "string",
      "deleted": true,
      "deletedAt": "string",
      "deletedBy": "string",
      "notificationGroup": {
        "_id": "string",
        "name": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_parentId": "string"
      },
      "data": {},
      "workflowIntegrationStatus": {}
    }
  }
  ```
</ResponseExample>


# Update workflow status
Source: https://v0.x-docs.novu.co/api-reference/workflows/update-workflow-status

put /v1/workflows/{workflowId}/status
Workflow was previously named notification template

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```bash cURL theme={null}
    curl --request PUT \
    --url https://api.novu.co/v1/workflows/{workflowId}/status \
    --header 'Authorization: <authorization>' \
    --header 'Content-Type: application/json' \
    --data '{
      "active": "<boolean>",
     }'
  ```

  ```javascript Node.js theme={null}
  import { Novu, TemplateVariableTypeEnum, FilterPartTypeEnum, StepTypeEnum } from '@novu/node';

  const novu = new Novu('<NOVU_API_KEY>');

  await novu.notificationTemplates.updateStatus("workflowId", false)
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->updateNotificationTemplateStatus($templateId, [
      'active' => true
  ])
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  client.update_notification_template_status('<insert-template-id>', { 'active' => true })
  ```

  ```python Python theme={null}
  from novu.api import NotificationTemplateApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"
  novu = NotificationTemplateApi(url, api_key).update_status(
      notification_template_id = "< The notification workflow ID of the workflow>",
  )
  ```

  ```java Java theme={null}
  import co.novu.Novu;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);
          novu.updateWorkflowStatus(workflowId, body);
      }
  }
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "net/http"
    "encoding/json"
  )

  func main() {
    url := "https://api.novu.co/v1/workflows/:workflowId/status"
    data := map[string]string{
      "active": true
    }
    jsonValue, _ := json.Marshal(data)
    req, _ := http.NewRequest("PUT", url, bytes.NewBuffer(jsonValue))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "ApiKey REPLACE_WITH_API_KEY")

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
  }
      
  ```

  ```kotlin Kotlin theme={null}
  import co.novu.Novu
  import co.novu.extensions.updateWorkflowStatus

  class Main {
      fun main(args: Array<String>) {
          val apiKey = "<NOVU_API_KEY>"

          val novu = Novu(apiKey)
          novu.updateWorkflowStatus(workflowId, body)
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": {
      "_id": "string",
      "name": "string",
      "description": "string",
      "active": true,
      "draft": true,
      "preferenceSettings": {
        "email": true,
        "sms": true,
        "in_app": true,
        "chat": true,
        "push": true
      },
      "critical": true,
      "tags": [
        "string"
      ],
      "steps": [
        {
          "_id": "string",
          "uuid": "string",
          "name": "string",
          "_templateId": "string",
          "active": true,
          "shouldStopOnFail": true,
          "template": {},
          "filters": [
            {
              "isNegated": true,
              "type": "BOOLEAN",
              "value": "AND",
              "children": [
                {
                  "field": "string",
                  "value": "string",
                  "operator": "LARGER",
                  "on": "subscriber"
                }
              ]
            }
          ],
          "_parentId": {},
          "metadata": {
            "amount": 0,
            "unit": "seconds",
            "digestKey": "string",
            "type": "regular",
            "backoff": true,
            "backoffAmount": 0,
            "backoffUnit": "seconds",
            "updateMode": true
          },
          "replyCallback": {}
        }
      ],
      "_organizationId": "string",
      "_creatorId": "string",
      "_environmentId": "string",
      "triggers": [
        {
          "type": "string",
          "identifier": "string",
          "variables": [
            {
              "name": "string"
            }
          ],
          "subscriberVariables": [
            {
              "name": "string"
            }
          ]
        }
      ],
      "_notificationGroupId": "string",
      "_parentId": "string",
      "deleted": true,
      "deletedAt": "string",
      "deletedBy": "string",
      "notificationGroup": {
        "_id": "string",
        "name": "string",
        "_environmentId": "string",
        "_organizationId": "string",
        "_parentId": "string"
      },
      "data": {},
      "workflowIntegrationStatus": {}
    }
  }
  ```
</ResponseExample>


# Novu Architecture Diagram
Source: https://v0.x-docs.novu.co/architecture/diagrams



# Novu Architecture Diagram powered by [terrastruct](https://terrastruct.com) and D2

If the diagram below is not rendering, please [click here](https://app.terrastruct.com/diagrams/1895866270) to view it on terrastruct.com.

<iframe title="Novu" />


# Introduction to Novu
Source: https://v0.x-docs.novu.co/architecture/introduction

Overview of Novu's Architecture

Novu is an open-source notification infrastructure designed to provide a robust, efficient, and flexible solution for managing notifications across various platforms.
The architecture of Novu is meticulously crafted to ensure accurate delivery of notifications while maintaining high performance and scalability.

Our systems are hosted on Amazon Web Services (AWS), ensuring a reliable and secure environment for our infrastructure.
We adhere to several industry-standard compliance certifications including SOC II, PCI, and GDPR which underline our commitment to security and data privacy.

## Framework Leveraged

* **Nestjs**: A progressive Node.js framework that is used for building efficient, reliable, and scalable server-side applications. Nestjs provides a high-level abstraction with a lot of out-of-the-box features, making it a perfect choice for building modular and maintainable applications.
* **Mongoose**: An elegant Object Document Mapper (ODM) for MongoDB, which simplifies the interaction with the database by providing a straightforward modeling of the application data. Mongoose’s features like schema validation, query building, and middleware support immensely help in building robust applications.
* **BullMQ**: A robust, fast, and reliable queue library for handling distributed jobs and messages in Node.js. It is instrumental in managing the processing of notification jobs ensuring they are handled in an efficient and reliable manner.

## Databases

* **MongoDB**: A NoSQL database that provides high performance, high availability, and easy scalability. It works on a document-oriented data model, which is extremely flexible and allows for varied, complex data structures to be stored and manipulated with ease.
* **Redis**: An in-memory data structure store, used as a database, cache, and message broker. It's exceptionally fast and provides support for various data structures like strings, hashes, lists, sets, etc. It's utilized in Novu for caching and as a reliable message broker for managing queues and real-time data processing.

## Scalability & Performance

The architecture of Novu is designed to scale horizontally to handle a growing number of notification requests. The use of microservices, container orchestration with Kubernetes, and leveraging AWS’s auto-scaling capabilities, ensure that the system can handle high loads while maintaining low latency and high throughput.

## Monitoring & Observability

Monitoring and observability are crucial for ensuring the reliable operation of Novu. Utilizing tools like Prometheus and Grafana, we've built a comprehensive monitoring and alerting system that provides real-time insights into the system’s performance and health.

## Security

Security is a paramount concern in Novu’s architecture. By adhering to industry-standard security practices and compliance certifications, we ensure that the data flowing through Novu is handled securely and in compliance with regulatory requirements.


# Concepts
Source: https://v0.x-docs.novu.co/getting-started/concepts

Learn about the key concepts of Novu

## Notification

A notification conveys information from source to recipient, triggered by a workflow acting as a message blueprint. Notifications can be individual or bundled as [digest](/workflows/digest) for user-friendliness.

## Messages

A message in Novu represents a notification delivered to a recipient on a particular channel. Messages contain information about the request that triggered its delivery, a view of the data sent to the recipient, and a timeline of its lifecycle events. [Learn more about messages](/workflows/messages).

## Workflow

All notifications are sent via a workflow. Each workflow acts as a container for the logic and blueprint that are associated with a type of notification in your system. [Learn more](/workflows/notification-workflows)

## Channel

A channel in Novu represents a configured provider, such as Sendgrid for email, to send notifications to your recipients. A channel is the communication-context domain with the recipients (subscribers).

Most providers within Novu use credentials that you supply to deliver notifications on your behalf. These credentials and other settings are what make a configured channel. [Learn more](/channels-and-providers/introduction)

## Subscriber

A subscriber in Novu represents someone who should receive a message. A subscriber's profile information contains important attributes about the subscriber that will be used in messages (name, email). The subscriber object can contain other key-value pairs that can be used to further personalize your messages. [Learn more about subscribers.](/subscribers/subscribers)

## Topics

Topics are a way to group subscribers together so that they can be notified of events at once. A topic is identified by a custom key. This can be helpful for things like sending out marketing emails or notifying users of new features. Topics can also be used to send notifications to the subscribers who have been grouped together based on their interests, location, activities and much more. [Learn more about topics.](/subscribers/topics)

## Activity Feed

Novu provides a notification activity feed that monitors every outgoing message associated with its relevant metadata. This can be used to monitor activity and discover potential issues with a specific provider or a channel type. [Learn more about the activity feed.](/activity-feed/introduction)

## Integration Store

With the help of the integration store, you can easily integrate your favorite delivery provider. During the runtime of the API, the Integrations Store is responsible for storing the configurations of all the providers. [Learn more](/channels-and-providers/integration-store)

## Providers

Providers are the channel service providers (Twilio, Sendgrid, APN, etc,) you connect to Novu so that it can send your notifications. Rather than replacing your existing providers, Novu passes your notifications to the providers you already use via these channel integrations. [Learn more about providers.](/channels-and-providers/introduction)

## Environment

* Production
* Development

Novu uses the concept of environments to ensure logical separation of your data and configuration. This means that subscribers, and preferences created in one environment are **never** accessible to another. [Learn more about environments.](/platform/environments)

## Handlebars & Helpers

Handlebars is a simple templating language that generates HTML.

Novu-specific Helpers make it possible to define custom iterators and other functionality that can invoke the passed block with a new context. [Learn more about helpers.](/content-creation-design/handlebars-helpers)

## Organization

An organization serves as a separate entity within your Novu account. Each organization you create has its own separate integration store, workflows, subscribers, and API keys. This separation of resources allows you to manage multi-tenant environments and separate domains within a single account.

Switching your organization in the UI only affects the UI and does not deactivate any organizations on the API side. Moreover, the message delivery for each organization operates simultaneously.

Keep in mind that workflows and integration stores for one organization cannot be used for subscribers of other organizations.

<img />

To create a new organization, you interact with a drop down menu in the bottom of the left navigation bar within Novu’s application. Type the name of your new organization, and if the name is new, you will see a button that enables you to add a new one.

<img />

To switch between organizations, you again interact with the same drop down menu and switch between the organizations you have in your Novu account.

<img />

## Notification Center

Notification Center is a beautifully designed and highly functional in-app experience for your users that you can add to your product quickly and effortlessly.

The core components of our Notification Center are:

* A list of notifications with real-time updates
* Notification preference management
* State management and actions for notifications (mark as read/unread, and delete)
* And more

[Learn more](/notification-center/introduction)

## Preference

A preference indicates a user's willingness to receive a particular type of notification. Preferences always belong to a user and can be paired with an identifier that represents the account or tenant that the user belongs to (for multi-tenant applications). [Learn more](/subscribers/preferences)

## Delay Actions

The delay action awaits a specified amount of time before moving on to trigger the following steps of the workflow. [Learn more](/workflows/delay-action)

## Digest

The digest engine collects multiple trigger events, aggregates them into a single message and delivers it to the subscriber. [Learn more](/workflows/digest)

## Layouts

Novu allows the creation of layouts - a specific HTML design or structure to wrap content of email notifications. Layouts can be manipulated and assigned to new or existing workflows within the Novu platform, allowing users to create, manage, and assign these layouts to workflows, so they can be reused to structure the appearance of notifications sent through the platform. [Learn more](/content-creation-design/layouts)

## Tenants

A tenant represents a group of users. As a developer, when your apps have organizations, they are referred to as tenants. Tenants in Novu provides the ability to tailor specific notification experiences to users of different **groups** or **organizations**. [Learn more about Novu Tenants.](/tenants/introduction)


# How Does Novu Work?
Source: https://v0.x-docs.novu.co/getting-started/how-novu-works



Novu comprises two fundamental components: an API for data exchange and a dashboard for designing notifications and their accompanying logical rules.

This section provides a broad overview of Novu's functionality, delving into key concepts for your initial Novu journey. If you prefer to dive into development, explore our **[Quick Start guides](/quickstarts/overview)**.

## Architecture

Novu's Object Communication Layer (OCL) is a structured framework that separates communication tasks into specialized components.
Similar to microservices, these components handle specific roles like message passing and data management. By doing so, OCL enhances system maintenance and scalability, making it easier to integrate new functionalities.

Novu's approach goes beyond this, optimizing communication protocols for seamless collaboration and adaptability. It's like providing a playbook for coordinating a dynamic game, ensuring all players are synchronized for any challenge.

<img />


# What is Novu?
Source: https://v0.x-docs.novu.co/getting-started/introduction

Novu is a full-stack (UI, API & GitOps) open source notification infrastructure tool and platform for building, managing, delivering, and monitoring all types of end-user notifications.

Novu supports a variety of common notification channels out-of-the-box, including **email**, **SMS**, **push**, **in-app**, and **chat**. Our platform is a developer-first product built for engineers that need to simplify the complexities of notification management, while working closely with product and marketing teams that need to provide, edit, and maintain notification content.

<AccordionGroup>
  <Accordion title="Get started with our quickstarts">
    Get started in minutes

    <CardGroup>
      <Card title="React" icon="react" href="/quickstarts/react">
        Embed a real-time notification center component in your React application.
      </Card>

      <Card title="Vue" icon="vuejs" href="/quickstarts/vue">
        Embed a real-time notification center component in your Vue application.
      </Card>

      <Card title="Angular" icon="angular" href="/quickstarts/angular">
        Embed a real-time notification center component in your Angular application.
      </Card>

      <Card
        title="Kotlin"
        icon={
<svg
    xmlns="http://www.w3.org/2000/svg"
    width="20"
    height="20"
    viewBox="0 0 256 256"
  >
    <defs>
      <linearGradient
        id="logosKotlinIcon0"
        x1="99.991%"
        x2=".01%"
        y1="-.011%"
        y2="100.01%"
      >
        <stop offset=".344%" stopColor="#E44857" />
        <stop offset="46.89%" stopColor="#C711E1" />
        <stop offset="100%" stopColor="#7F52FF" />
      </linearGradient>
    </defs>
    <path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosKotlinIcon0)" d="M256 256H0V0h256L128 127.949z" />
  </svg>}
        href="/quickstarts/kotlin"
      >
        Embed a real-time notification center component in your Kotlin application.
      </Card>

      <Card
        title="PHP"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#deviconPhp0)" d="M0 64c0 18.593 28.654 33.667 64 33.667c35.346 0 64-15.074 64-33.667c0-18.593-28.655-33.667-64-33.667C28.654 30.333 0 45.407 0 64Z"/><path fill="#777bb3" d="M64 95.167c33.965 0 61.5-13.955 61.5-31.167c0-17.214-27.535-31.167-61.5-31.167S2.5 46.786 2.5 64c0 17.212 27.535 31.167 61.5 31.167Z"/><path d="M34.772 67.864c2.793 0 4.877-.515 6.196-1.53c1.306-1.006 2.207-2.747 2.68-5.175c.44-2.27.272-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.464l-2.473 12.732zM20.173 83.547a.694.694 0 0 1-.68-.828l6.557-33.738a.695.695 0 0 1 .68-.561h14.134c4.442 0 7.748 1.206 9.827 3.585c2.088 2.39 2.734 5.734 1.917 9.935c-.333 1.711-.905 3.3-1.7 4.724a15.818 15.818 0 0 1-3.128 3.92c-1.531 1.432-3.264 2.472-5.147 3.083c-1.852.604-4.232.91-7.07.91h-5.724l-1.634 8.408a.695.695 0 0 1-.682.562z"/><path fill="#fff" d="M34.19 55.826h3.891c3.107 0 4.186.682 4.553 1.089c.607.674.723 2.097.331 4.112c-.439 2.257-1.253 3.858-2.42 4.756c-1.194.92-3.138 1.386-5.773 1.386h-2.786l2.205-11.342zm6.674-8.1H26.731a1.39 1.39 0 0 0-1.364 1.123L18.81 82.588a1.39 1.39 0 0 0 1.363 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.151c2.912 0 5.364-.318 7.287-.944c1.977-.642 3.796-1.731 5.406-3.237a16.522 16.522 0 0 0 3.259-4.087c.831-1.487 1.429-3.147 1.775-4.931c.86-4.423.161-7.964-2.076-10.524c-2.216-2.537-5.698-3.823-10.349-3.823zM30.301 68.557h4.471c2.963 0 5.17-.557 6.62-1.675c1.451-1.116 2.428-2.98 2.938-5.591c.485-2.508.264-4.277-.665-5.308c-.931-1.03-2.791-1.546-5.584-1.546h-5.036l-2.743 14.12m10.563-19.445c4.252 0 7.353 1.117 9.303 3.348c1.95 2.232 2.536 5.347 1.76 9.346c-.322 1.648-.863 3.154-1.625 4.518c-.764 1.366-1.76 2.614-2.991 3.747c-1.468 1.373-3.097 2.352-4.892 2.935c-1.794.584-4.08.875-6.857.875h-6.296l-1.743 8.97h-7.35l6.558-33.739h14.133"/><path d="M69.459 74.577a.694.694 0 0 1-.682-.827l2.9-14.928c.277-1.42.209-2.438-.19-2.87c-.245-.263-.979-.704-3.15-.704h-5.256l-3.646 18.768a.695.695 0 0 1-.683.56h-7.29a.695.695 0 0 1-.683-.826l6.558-33.739a.695.695 0 0 1 .682-.561h7.29a.695.695 0 0 1 .683.826L64.41 48.42h5.653c4.307 0 7.227.758 8.928 2.321c1.733 1.593 2.275 4.14 1.608 7.573l-3.051 15.702a.695.695 0 0 1-.682.56h-7.407z"/><path fill="#fff" d="M65.31 38.755h-7.291a1.39 1.39 0 0 0-1.364 1.124l-6.557 33.738a1.39 1.39 0 0 0 1.363 1.654h7.291a1.39 1.39 0 0 0 1.364-1.124l3.537-18.205h4.682c2.168 0 2.624.463 2.641.484c.132.14.305.795.019 2.264l-2.9 14.927a1.39 1.39 0 0 0 1.364 1.654h7.408a1.39 1.39 0 0 0 1.363-1.124l3.051-15.7c.715-3.686.103-6.45-1.82-8.217c-1.836-1.686-4.91-2.505-9.398-2.505h-4.81l1.421-7.315a1.39 1.39 0 0 0-1.364-1.655zm0 1.39l-1.743 8.968h6.496c4.087 0 6.907.714 8.457 2.14c1.553 1.426 2.017 3.735 1.398 6.93l-3.052 15.699h-7.407l2.901-14.928c.33-1.698.208-2.856-.365-3.474c-.573-.617-1.793-.926-3.658-.926h-5.829l-3.756 19.327H51.46l6.558-33.739h7.292z"/><path d="M92.136 67.864c2.793 0 4.878-.515 6.198-1.53c1.304-1.006 2.206-2.747 2.679-5.175c.44-2.27.273-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.463l-2.475 12.732zM77.54 83.547a.694.694 0 0 1-.682-.828l6.557-33.738a.695.695 0 0 1 .682-.561H98.23c4.442 0 7.748 1.206 9.826 3.585c2.089 2.39 2.734 5.734 1.917 9.935a15.878 15.878 0 0 1-1.699 4.724a15.838 15.838 0 0 1-3.128 3.92c-1.53 1.432-3.265 2.472-5.147 3.083c-1.852.604-4.232.91-7.071.91h-5.723l-1.633 8.408a.695.695 0 0 1-.683.562z"/><path fill="#fff" d="M91.555 55.826h3.891c3.107 0 4.186.682 4.552 1.089c.61.674.724 2.097.333 4.112c-.44 2.257-1.254 3.858-2.421 4.756c-1.195.92-3.139 1.386-5.773 1.386h-2.786l2.204-11.342zm6.674-8.1H84.096a1.39 1.39 0 0 0-1.363 1.123l-6.558 33.739a1.39 1.39 0 0 0 1.364 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.15c2.911 0 5.364-.318 7.286-.944c1.978-.642 3.797-1.731 5.408-3.238a16.52 16.52 0 0 0 3.258-4.086c.832-1.487 1.428-3.147 1.775-4.931c.86-4.423.162-7.964-2.076-10.524c-2.216-2.537-5.697-3.823-10.35-3.823zM87.666 68.557h4.47c2.964 0 5.17-.557 6.622-1.675c1.45-1.116 2.428-2.98 2.936-5.591c.487-2.508.266-4.277-.665-5.308c-.93-1.03-2.791-1.546-5.583-1.546h-5.035Zm10.563-19.445c4.251 0 7.354 1.117 9.303 3.348c1.95 2.232 2.537 5.347 1.759 9.346c-.32 1.648-.862 3.154-1.624 4.518c-.763 1.366-1.76 2.614-2.992 3.747c-1.467 1.373-3.097 2.352-4.892 2.935c-1.793.584-4.078.875-6.856.875h-6.295l-1.745 8.97h-7.35l6.558-33.739h14.133"/><defs><radialGradient id="deviconPhp0" cx="0" cy="0" r="1" gradientTransform="translate(38.426 42.169) scale(84.04136)" gradientUnits="userSpaceOnUse"><stop stopColor="#AEB2D5"/><stop offset=".3" stopColor="#AEB2D5"/><stop offset=".75" stopColor="#484C89"/><stop offset="1" stopColor="#484C89"/></radialGradient></defs></svg>
}
        href="/quickstarts/php"
      >
        Embed a real-time notification center component in your PHP application.
      </Card>

      <Card
        title="Ruby"
        icon={<svg xmlns="http://www.w3.org/2000/svg" width="20" height="19.93" viewBox="0 0 256 255"><defs><linearGradient id="logosRuby0" x1="84.75%" x2="58.254%" y1="111.399%" y2="64.584%"><stop offset="0%" stopColor="#FB7655"/><stop offset="0%" stopColor="#FB7655"/><stop offset="41%" stopColor="#E42B1E"/><stop offset="99%" stopColor="#900"/><stop offset="100%" stopColor="#900"/></linearGradient><linearGradient id="logosRuby1" x1="116.651%" x2="1.746%" y1="60.89%" y2="19.288%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby2" x1="75.774%" x2="38.978%" y1="219.327%" y2="7.829%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby3" x1="50.012%" x2="66.483%" y1="7.234%" y2="79.135%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E57252"/><stop offset="46%" stopColor="#DE3B20"/><stop offset="99%" stopColor="#A60003"/><stop offset="100%" stopColor="#A60003"/></linearGradient><linearGradient id="logosRuby4" x1="46.174%" x2="49.932%" y1="16.348%" y2="83.047%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E4714E"/><stop offset="56%" stopColor="#BE1A0D"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby5" x1="36.965%" x2="49.528%" y1="15.594%" y2="92.478%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="18%" stopColor="#E46342"/><stop offset="40%" stopColor="#C82410"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby6" x1="13.609%" x2="85.764%" y1="58.346%" y2="-46.717%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="54%" stopColor="#C81F11"/><stop offset="99%" stopColor="#BF0905"/><stop offset="100%" stopColor="#BF0905"/></linearGradient><linearGradient id="logosRuby7" x1="27.624%" x2="50.745%" y1="21.135%" y2="79.056%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="31%" stopColor="#DE4024"/><stop offset="99%" stopColor="#BF190B"/><stop offset="100%" stopColor="#BF190B"/></linearGradient><linearGradient id="logosRuby8" x1="-20.667%" x2="104.242%" y1="122.282%" y2="-6.342%"><stop offset="0%" stopColor="#BD0012"/><stop offset="0%" stopColor="#BD0012"/><stop offset="7%" stopColor="#FFF"/><stop offset="17%" stopColor="#FFF"/><stop offset="27%" stopColor="#C82F1C"/><stop offset="33%" stopColor="#820C01"/><stop offset="46%" stopColor="#A31601"/><stop offset="72%" stopColor="#B31301"/><stop offset="99%" stopColor="#E82609"/><stop offset="100%" stopColor="#E82609"/></linearGradient><linearGradient id="logosRuby9" x1="58.792%" x2="11.964%" y1="65.205%" y2="50.128%"><stop offset="0%" stopColor="#8C0C01"/><stop offset="0%" stopColor="#8C0C01"/><stop offset="54%" stopColor="#990C00"/><stop offset="99%" stopColor="#A80D0E"/><stop offset="100%" stopColor="#A80D0E"/></linearGradient><linearGradient id="logosRubya" x1="79.319%" x2="23.088%" y1="62.754%" y2="17.888%"><stop offset="0%" stopColor="#7E110B"/><stop offset="0%" stopColor="#7E110B"/><stop offset="99%" stopColor="#9E0C00"/><stop offset="100%" stopColor="#9E0C00"/></linearGradient><linearGradient id="logosRubyb" x1="92.88%" x2="59.841%" y1="74.122%" y2="39.704%"><stop offset="0%" stopColor="#79130D"/><stop offset="0%" stopColor="#79130D"/><stop offset="99%" stopColor="#9E120B"/><stop offset="100%" stopColor="#9E120B"/></linearGradient><linearGradient id="logosRubyc" x1="56.57%" x2="3.105%" y1="101.717%" y2="11.993%"><stop offset="0%" stopColor="#8B2114"/><stop offset="0%" stopColor="#8B2114"/><stop offset="43%" stopColor="#9E100A"/><stop offset="99%" stopColor="#B3100C"/><stop offset="100%" stopColor="#B3100C"/></linearGradient><linearGradient id="logosRubyd" x1="30.87%" x2="92.471%" y1="35.599%" y2="100.694%"><stop offset="0%" stopColor="#B31000"/><stop offset="0%" stopColor="#B31000"/><stop offset="44%" stopColor="#910F08"/><stop offset="99%" stopColor="#791C12"/><stop offset="100%" stopColor="#791C12"/></linearGradient><radialGradient id="logosRubye" cx="32.001%" cy="40.21%" r="69.573%" fx="32.001%" fy="40.21%"><stop offset="0%" stopColor="#A80D00"/><stop offset="0%" stopColor="#A80D00"/><stop offset="99%" stopColor="#7E0E08"/><stop offset="100%" stopColor="#7E0E08"/></radialGradient><radialGradient id="logosRubyf" cx="13.549%" cy="40.86%" r="88.386%" fx="13.549%" fy="40.86%"><stop offset="0%" stopColor="#A30C00"/><stop offset="0%" stopColor="#A30C00"/><stop offset="99%" stopColor="#800E08"/><stop offset="100%" stopColor="#800E08"/></radialGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby0)" d="m197.467 167.764l-145.52 86.41l188.422-12.787L254.88 51.393l-57.414 116.37Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby1)" d="M240.677 241.257L224.482 129.48l-44.113 58.25l60.308 53.528Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby2)" d="m240.896 241.257l-118.646-9.313l-69.674 21.986l188.32-12.673Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby3)" d="m52.744 253.955l29.64-97.1L17.16 170.8l35.583 83.154Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby4)" d="M180.358 188.05L153.085 81.226l-78.047 73.16l105.32 33.666Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby5)" d="m248.693 82.73l-73.777-60.256l-20.544 66.418l94.321-6.162Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby6)" d="M214.191.99L170.8 24.97L143.424.669l70.767.322Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby7)" d="m0 203.372l18.177-33.151l-14.704-39.494L0 203.372Z"/><path fill="#FFF" d="m2.496 129.48l14.794 41.963l64.283-14.422l73.39-68.207l20.712-65.787L143.063 0L87.618 20.75c-17.469 16.248-51.366 48.396-52.588 49c-1.21.618-22.384 40.639-32.534 59.73Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby8)" d="M54.442 54.094c37.86-37.538 86.667-59.716 105.397-40.818c18.72 18.898-1.132 64.823-38.992 102.349c-37.86 37.525-86.062 60.925-104.78 42.027c-18.73-18.885.515-66.032 38.375-103.558Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby9)" d="m52.744 253.916l29.408-97.409l97.665 31.376c-35.312 33.113-74.587 61.106-127.073 66.033Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubya)" d="m155.092 88.622l25.073 99.313c29.498-31.016 55.972-64.36 68.938-105.603l-94.01 6.29Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyb)" d="M248.847 82.833c10.035-30.282 12.35-73.725-34.966-81.791l-38.825 21.445l73.791 60.346Z"/><path fill="#9E1209" d="M0 202.935c1.39 49.979 37.448 50.724 52.808 51.162l-35.48-82.86L0 202.935Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubye)" d="M155.232 88.777c22.667 13.932 68.35 41.912 69.276 42.426c1.44.81 19.695-30.784 23.838-48.64l-93.114 6.214Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyf)" d="m82.113 156.507l39.313 75.848c23.246-12.607 41.45-27.967 58.121-44.42l-97.434-31.428Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyc)" d="m17.174 171.34l-5.57 66.328c10.51 14.357 24.97 15.605 40.136 14.486c-10.973-27.311-32.894-81.92-34.566-80.814Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyd)" d="m174.826 22.654l78.1 10.96c-4.169-17.662-16.969-29.06-38.787-32.623l-39.313 21.663Z"/></svg>

}
        href="/quickstarts/ruby"
      >
        Embed a real-time notification center component in your Ruby application.
      </Card>
    </CardGroup>
  </Accordion>

  <Accordion title="Explore our SDKs">
    You can interface with Novu's API either over REST, or via libraries for certain languages. Below is a list of our official, supported libraries.

    ### Client Side

    The Client side libraries and components helps to add a fully functional notification center to your application.

    <CardGroup>
      <Card title="React" icon="react" href="/sdks/react">
        Embed a real-time notification center component in your React application.
      </Card>

      <Card title="Vue" icon="vuejs" href="/sdks/vue">
        Embed a real-time notification center component in your Vue application.
      </Card>

      <Card title="Angular" icon="angular" href="/sdks/angular">
        Embed a real-time notification center component in your Angular application.
      </Card>

      <Card title="Web Component" icon="square-js" href="/sdks/web-component">
        Embed a real-time notification center component in your JavaScript application.
      </Card>

      <Card title="IFrame Embed" icon="frame" href="/sdks/iframe-embed">
        Embed a real-time notification center inside an iframe using our embedded script.
      </Card>

      <Card title="Headless JavaScript" icon="js" href="/sdks/headless-javascript-service">
        Embed a notification system into any framework or vanilla JavaScript project, without being constrained by our default UI or dependencies.
      </Card>
    </CardGroup>

    ### Server Side

    The Server Side libraries help to trigger notifications and interact with all of Novu’s API seamlessly.

    <CardGroup>
      <Card
        title="Node.js"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="21.47" viewBox="0 0 512 314"><defs><linearGradient id="logosNodejs0" x1="68.188%" x2="27.823%" y1="17.487%" y2="89.755%"><stop offset="0%" stopColor="#41873F"/><stop offset="32.88%" stopColor="#418B3D"/><stop offset="63.52%" stopColor="#419637"/><stop offset="93.19%" stopColor="#3FA92D"/><stop offset="100%" stopColor="#3FAE2A"/></linearGradient><linearGradient id="logosNodejs1" x1="43.277%" x2="159.245%" y1="55.169%" y2="-18.306%"><stop offset="13.76%" stopColor="#41873F"/><stop offset="40.32%" stopColor="#54A044"/><stop offset="71.36%" stopColor="#66B848"/><stop offset="90.81%" stopColor="#6CC04A"/></linearGradient><linearGradient id="logosNodejs2" x1="-4413.77%" x2="5327.93%" y1="13.43%" y2="13.43%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs3" x1="-4.389%" x2="101.499%" y1="49.997%" y2="49.997%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs4" x1="-9713.77%" x2="27.93%" y1="36.21%" y2="36.21%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs5" x1="-103.861%" x2="100.797%" y1="50.275%" y2="50.275%"><stop offset="9.192%" stopColor="#6CC04A"/><stop offset="28.64%" stopColor="#66B848"/><stop offset="59.68%" stopColor="#54A044"/><stop offset="86.24%" stopColor="#41873F"/></linearGradient><linearGradient id="logosNodejs6" x1="130.613%" x2="4.393%" y1="-211.069%" y2="201.605%"><stop offset="0%" stopColor="#41873F"/><stop offset="32.88%" stopColor="#418B3D"/><stop offset="63.52%" stopColor="#419637"/><stop offset="93.19%" stopColor="#3FA92D"/><stop offset="100%" stopColor="#3FAE2A"/></linearGradient><path id="logosNodejs7" d="M57.903 1.85a5.957 5.957 0 0 0-5.894 0L3.352 29.933c-1.85 1.04-2.89 3.005-2.89 5.085v56.286c0 2.08 1.156 4.045 2.89 5.085l48.657 28.085a5.957 5.957 0 0 0 5.894 0l48.658-28.085c1.849-1.04 2.89-3.005 2.89-5.085V35.019c0-2.08-1.157-4.045-2.89-5.085L57.903 1.85Z"/></defs><g fill="none"><path fill="#539E43" d="M253.11 313.094c-1.733 0-3.351-.462-4.854-1.271l-15.371-9.13c-2.312-1.272-1.156-1.734-.462-1.965c3.12-1.04 3.698-1.272 6.934-3.12c.347-.232.81-.116 1.156.115l11.789 7.05c.462.231 1.04.231 1.386 0l46.115-26.698c.462-.231.694-.694.694-1.271v-53.28c0-.579-.232-1.04-.694-1.272l-46.115-26.582c-.462-.232-1.04-.232-1.386 0l-46.115 26.582c-.462.231-.694.809-.694 1.271v53.28c0 .463.232 1.04.694 1.272l12.598 7.281c6.819 3.467 11.095-.578 11.095-4.623v-52.587c0-.693.578-1.387 1.387-1.387h5.894c.694 0 1.387.578 1.387 1.387v52.587c0 9.13-4.97 14.447-13.638 14.447c-2.658 0-4.738 0-10.633-2.89l-12.135-6.934c-3.005-1.733-4.854-4.97-4.854-8.437v-53.28c0-3.467 1.849-6.704 4.854-8.437l46.114-26.698c2.89-1.618 6.82-1.618 9.709 0l46.114 26.698c3.005 1.733 4.855 4.97 4.855 8.437v53.28c0 3.467-1.85 6.704-4.855 8.437l-46.114 26.698c-1.503.694-3.236 1.04-4.854 1.04Zm14.216-36.637c-20.225 0-24.386-9.246-24.386-17.105c0-.694.578-1.387 1.387-1.387h6.01c.693 0 1.271.462 1.271 1.156c.925 6.125 3.583 9.13 15.834 9.13c9.708 0 13.87-2.196 13.87-7.397c0-3.005-1.157-5.2-16.297-6.703c-12.598-1.272-20.457-4.045-20.457-14.1c0-9.362 7.86-14.91 21.035-14.91c14.793 0 22.075 5.086 23 16.18c0 .348-.116.694-.347 1.041c-.232.231-.578.462-.925.462h-6.01c-.578 0-1.156-.462-1.271-1.04c-1.387-6.356-4.97-8.437-14.447-8.437c-10.633 0-11.905 3.699-11.905 6.472c0 3.352 1.503 4.392 15.834 6.241c14.216 1.85 20.92 4.508 20.92 14.447c-.116 10.171-8.437 15.95-23.116 15.95Z"/><path fill="#333" d="M110.028 104.712c0-2.08-1.156-4.046-3.005-5.086l-49.004-28.2c-.81-.463-1.734-.694-2.658-.81h-.463c-.924 0-1.849.347-2.658.81l-49.004 28.2c-1.85 1.04-3.005 3.005-3.005 5.086l.116 75.817c0 1.04.578 2.08 1.502 2.543c.925.578 2.08.578 2.89 0l29.125-16.643c1.849-1.04 3.005-3.005 3.005-5.085v-35.482c0-2.08 1.155-4.045 3.005-5.085l12.366-7.166c.925-.578 1.965-.81 3.005-.81c1.04 0 2.08.232 2.89.81l12.366 7.166c1.85 1.04 3.005 3.004 3.005 5.085v35.482c0 2.08 1.156 4.045 3.005 5.085l29.125 16.643a2.82 2.82 0 0 0 3.005 0c.925-.463 1.503-1.503 1.503-2.543l-.116-75.817ZM345.571.347c-.924-.463-2.08-.463-2.89 0c-.924.578-1.502 1.502-1.502 2.542v75.125c0 .693-.346 1.386-1.04 1.849c-.693.346-1.387.346-2.08 0l-12.251-7.05a5.957 5.957 0 0 0-5.895 0l-49.004 28.316c-1.849 1.04-3.005 3.005-3.005 5.085v56.516c0 2.08 1.156 4.046 3.005 5.086l49.004 28.316a5.957 5.957 0 0 0 5.895 0l49.004-28.316c1.849-1.04 3.005-3.005 3.005-5.086V21.844c0-2.196-1.156-4.16-3.005-5.201L345.572.347Zm-4.507 143.776c0 .578-.231 1.04-.694 1.271l-16.758 9.708a1.714 1.714 0 0 1-1.503 0l-16.758-9.708c-.463-.231-.694-.809-.694-1.271v-19.417c0-.578.231-1.04.694-1.271l16.758-9.709a1.714 1.714 0 0 1 1.503 0l16.758 9.709c.463.23.694.809.694 1.271v19.417Zm167.584-19.879c1.85-1.04 2.89-3.005 2.89-5.086v-13.753c0-2.08-1.156-4.045-2.89-5.085l-48.657-28.2a5.957 5.957 0 0 0-5.895 0l-49.004 28.315c-1.85 1.04-3.005 3.005-3.005 5.085v56.517c0 2.08 1.156 4.045 3.005 5.085l48.657 27.738c1.85 1.04 4.046 1.04 5.78 0L489 178.45c.925-.463 1.503-1.503 1.503-2.543c0-1.04-.578-2.08-1.503-2.543l-49.235-28.316c-.925-.578-1.503-1.502-1.503-2.542v-17.683c0-1.04.578-2.08 1.503-2.543l15.371-8.784a2.821 2.821 0 0 1 3.005 0l15.372 8.784c.925.578 1.502 1.502 1.502 2.543v13.869c0 1.04.578 2.08 1.503 2.542a2.82 2.82 0 0 0 3.005 0l29.125-16.99Z"/><path fill="#539E43" d="M456.292 121.585a1.05 1.05 0 0 1 1.156 0l9.362 5.432c.346.232.577.578.577 1.04v10.865c0 .462-.23.809-.577 1.04l-9.362 5.432a1.05 1.05 0 0 1-1.156 0l-9.361-5.432c-.347-.231-.578-.578-.578-1.04v-10.864c0-.463.23-.81.578-1.04l9.361-5.433Z"/><g transform="translate(134.068 70.501)"><mask id="logosNodejs8" fill="#fff"><use href="#logosNodejs7"/></mask><use fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs0)" href="#logosNodejs7"/><g mask="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs8)"><path d="M51.893 1.85L3.121 29.933C1.27 30.974 0 32.94 0 35.02v56.286c0 1.387.578 2.658 1.502 3.698L56.285 1.156c-1.387-.231-3.005-.116-4.392.693Zm4.739 123.203c.462-.116.925-.347 1.387-.578l48.773-28.085c1.85-1.04 3.005-3.005 3.005-5.085V35.019c0-1.502-.694-3.005-1.734-4.045l-51.43 94.079Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs1)" d="M106.676 29.934L57.788 1.85a8.025 8.025 0 0 0-1.503-.578L1.502 95.12a6.082 6.082 0 0 0 1.619 1.387l48.888 28.085c1.387.809 3.005 1.04 4.507.577l51.432-94.078c-.347-.462-.81-.81-1.272-1.156Z"/></g><g mask="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs8)"><path d="M109.797 91.305V35.019c0-2.08-1.271-4.045-3.12-5.085L57.786 1.85a5.106 5.106 0 0 0-1.848-.693l53.511 91.42c.231-.347.347-.809.347-1.271ZM3.12 29.934C1.272 30.974 0 32.94 0 35.02v56.286c0 2.08 1.387 4.045 3.12 5.085l48.889 28.085c1.156.693 2.427.925 3.814.693L3.467 29.818l-.346.116Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs2)" fillRule="evenodd" d="m50.391.809l-.693.347h.924l-.231-.347Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs3)" fillRule="evenodd" d="M106.792 105.636c1.387-.809 2.427-2.196 2.89-3.698L56.053 10.402c-1.387-.231-2.89-.116-4.16.693L3.351 39.065l52.355 95.465a8.057 8.057 0 0 0 2.196-.693l48.889-28.2Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs4)" fillRule="evenodd" d="m111.3 104.712l-.347-.578v.809l.346-.231Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs5)" fillRule="evenodd" d="m106.792 105.636l-48.773 28.085a6.973 6.973 0 0 1-2.196.693l.925 1.734l54.089-31.32v-.694l-1.387-2.312c-.231 1.618-1.271 3.005-2.658 3.814Z" transform="translate(0 -9.246)"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosNodejs6)" fillRule="evenodd" d="m106.792 105.636l-48.773 28.085a6.973 6.973 0 0 1-2.196.693l.925 1.734l54.089-31.32v-.694l-1.387-2.312c-.231 1.618-1.271 3.005-2.658 3.814Z" transform="translate(0 -9.246)"/></g></g></g></svg>
}
        href="/sdks/nodejs"
      >
        Connect your Node app to Novu via the Node.js SDK.
      </Card>

      <Card
        title="Go"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="13.13" viewBox="0 0 512 192"><path fill="#00ACD7" d="m292.533 13.295l1.124.75c13.212 8.725 22.685 20.691 28.917 35.15c1.496 2.243.499 3.49-2.493 4.237l-5.063 1.296c-11.447 2.949-20.53 5.429-31.827 8.378l-6.443 1.678c-2.32.574-2.96.333-5.428-2.477l-.348-.399c-3.519-3.988-6.155-6.652-10.817-9.03l-.899-.443c-15.705-7.727-30.911-5.484-45.12 3.74c-16.952 10.968-25.677 27.172-25.428 47.364c.25 19.942 13.96 36.395 33.654 39.137c16.951 2.244 31.16-3.739 42.378-16.452c2.244-2.743 4.238-5.734 6.73-9.224h-48.11c-5.235 0-6.481-3.24-4.736-7.478l.864-2.035c3.204-7.454 8.173-18.168 11.4-24.294l.704-1.319c.862-1.494 2.612-3.513 5.977-3.513h80.224c3.603-11.415 9.449-22.201 17.246-32.407c18.198-23.931 40.135-36.396 69.8-41.63c25.427-4.488 49.359-1.995 71.046 12.713c19.694 13.461 31.909 31.66 35.15 55.59c4.237 33.654-5.485 61.075-28.668 84.508c-16.453 16.702-36.645 27.172-59.829 31.908c-6.73 1.247-13.461 1.496-19.942 2.244c-22.685-.499-43.376-6.98-60.826-21.937c-12.273-10.61-20.727-23.648-24.928-38.828a104.937 104.937 0 0 1-10.47 16.89c-17.949 23.683-41.381 38.39-71.046 42.38c-24.43 3.24-47.115-1.497-67.058-16.454c-18.447-13.96-28.917-32.407-31.66-55.34c-3.24-27.173 4.737-51.603 21.19-73.041c17.7-23.184 41.132-37.891 69.8-43.126c22.999-4.16 45.037-1.595 64.936 11.464ZM411.12 49.017l-.798.178c-23.183 5.235-38.14 19.942-43.624 43.375c-4.488 19.444 4.985 39.138 22.934 47.115c13.71 5.983 27.421 5.235 40.633-1.496c19.694-10.22 30.413-26.175 31.66-47.613c-.25-3.24-.25-5.734-.749-8.227c-4.436-24.401-26.664-38.324-50.056-33.332ZM116.416 94.564c.997 0 1.496.748 1.496 1.745l-.499 5.983c0 .997-.997 1.745-1.745 1.745l-54.344-.249c-.997 0-1.246-.748-.748-1.496l3.49-6.232c.499-.748 1.496-1.496 2.493-1.496h49.857ZM121.9 71.63c.997 0 1.496.748 1.247 1.496l-1.995 5.983c-.249.997-1.246 1.495-2.243 1.495l-117.912.25c-.997 0-1.246-.499-.748-1.247l5.235-6.73c.499-.748 1.745-1.247 2.742-1.247H121.9Zm12.963-22.934c.997 0 1.246.748.748 1.496l-4.238 6.481c-.499.748-1.745 1.496-2.493 1.496l-90.24-.25c-.998 0-1.247-.498-.749-1.246l5.235-6.73c.499-.748 1.745-1.247 2.742-1.247h88.995Z"/></svg>
}
        href="/sdks/go"
      >
        Connect your Golang app to Novu via the Go SDK.
      </Card>

      <Card
        title="PHP"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#deviconPhp0)" d="M0 64c0 18.593 28.654 33.667 64 33.667c35.346 0 64-15.074 64-33.667c0-18.593-28.655-33.667-64-33.667C28.654 30.333 0 45.407 0 64Z"/><path fill="#777bb3" d="M64 95.167c33.965 0 61.5-13.955 61.5-31.167c0-17.214-27.535-31.167-61.5-31.167S2.5 46.786 2.5 64c0 17.212 27.535 31.167 61.5 31.167Z"/><path d="M34.772 67.864c2.793 0 4.877-.515 6.196-1.53c1.306-1.006 2.207-2.747 2.68-5.175c.44-2.27.272-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.464l-2.473 12.732zM20.173 83.547a.694.694 0 0 1-.68-.828l6.557-33.738a.695.695 0 0 1 .68-.561h14.134c4.442 0 7.748 1.206 9.827 3.585c2.088 2.39 2.734 5.734 1.917 9.935c-.333 1.711-.905 3.3-1.7 4.724a15.818 15.818 0 0 1-3.128 3.92c-1.531 1.432-3.264 2.472-5.147 3.083c-1.852.604-4.232.91-7.07.91h-5.724l-1.634 8.408a.695.695 0 0 1-.682.562z"/><path fill="#fff" d="M34.19 55.826h3.891c3.107 0 4.186.682 4.553 1.089c.607.674.723 2.097.331 4.112c-.439 2.257-1.253 3.858-2.42 4.756c-1.194.92-3.138 1.386-5.773 1.386h-2.786l2.205-11.342zm6.674-8.1H26.731a1.39 1.39 0 0 0-1.364 1.123L18.81 82.588a1.39 1.39 0 0 0 1.363 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.151c2.912 0 5.364-.318 7.287-.944c1.977-.642 3.796-1.731 5.406-3.237a16.522 16.522 0 0 0 3.259-4.087c.831-1.487 1.429-3.147 1.775-4.931c.86-4.423.161-7.964-2.076-10.524c-2.216-2.537-5.698-3.823-10.349-3.823zM30.301 68.557h4.471c2.963 0 5.17-.557 6.62-1.675c1.451-1.116 2.428-2.98 2.938-5.591c.485-2.508.264-4.277-.665-5.308c-.931-1.03-2.791-1.546-5.584-1.546h-5.036l-2.743 14.12m10.563-19.445c4.252 0 7.353 1.117 9.303 3.348c1.95 2.232 2.536 5.347 1.76 9.346c-.322 1.648-.863 3.154-1.625 4.518c-.764 1.366-1.76 2.614-2.991 3.747c-1.468 1.373-3.097 2.352-4.892 2.935c-1.794.584-4.08.875-6.857.875h-6.296l-1.743 8.97h-7.35l6.558-33.739h14.133"/><path d="M69.459 74.577a.694.694 0 0 1-.682-.827l2.9-14.928c.277-1.42.209-2.438-.19-2.87c-.245-.263-.979-.704-3.15-.704h-5.256l-3.646 18.768a.695.695 0 0 1-.683.56h-7.29a.695.695 0 0 1-.683-.826l6.558-33.739a.695.695 0 0 1 .682-.561h7.29a.695.695 0 0 1 .683.826L64.41 48.42h5.653c4.307 0 7.227.758 8.928 2.321c1.733 1.593 2.275 4.14 1.608 7.573l-3.051 15.702a.695.695 0 0 1-.682.56h-7.407z"/><path fill="#fff" d="M65.31 38.755h-7.291a1.39 1.39 0 0 0-1.364 1.124l-6.557 33.738a1.39 1.39 0 0 0 1.363 1.654h7.291a1.39 1.39 0 0 0 1.364-1.124l3.537-18.205h4.682c2.168 0 2.624.463 2.641.484c.132.14.305.795.019 2.264l-2.9 14.927a1.39 1.39 0 0 0 1.364 1.654h7.408a1.39 1.39 0 0 0 1.363-1.124l3.051-15.7c.715-3.686.103-6.45-1.82-8.217c-1.836-1.686-4.91-2.505-9.398-2.505h-4.81l1.421-7.315a1.39 1.39 0 0 0-1.364-1.655zm0 1.39l-1.743 8.968h6.496c4.087 0 6.907.714 8.457 2.14c1.553 1.426 2.017 3.735 1.398 6.93l-3.052 15.699h-7.407l2.901-14.928c.33-1.698.208-2.856-.365-3.474c-.573-.617-1.793-.926-3.658-.926h-5.829l-3.756 19.327H51.46l6.558-33.739h7.292z"/><path d="M92.136 67.864c2.793 0 4.878-.515 6.198-1.53c1.304-1.006 2.206-2.747 2.679-5.175c.44-2.27.273-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.463l-2.475 12.732zM77.54 83.547a.694.694 0 0 1-.682-.828l6.557-33.738a.695.695 0 0 1 .682-.561H98.23c4.442 0 7.748 1.206 9.826 3.585c2.089 2.39 2.734 5.734 1.917 9.935a15.878 15.878 0 0 1-1.699 4.724a15.838 15.838 0 0 1-3.128 3.92c-1.53 1.432-3.265 2.472-5.147 3.083c-1.852.604-4.232.91-7.071.91h-5.723l-1.633 8.408a.695.695 0 0 1-.683.562z"/><path fill="#fff" d="M91.555 55.826h3.891c3.107 0 4.186.682 4.552 1.089c.61.674.724 2.097.333 4.112c-.44 2.257-1.254 3.858-2.421 4.756c-1.195.92-3.139 1.386-5.773 1.386h-2.786l2.204-11.342zm6.674-8.1H84.096a1.39 1.39 0 0 0-1.363 1.123l-6.558 33.739a1.39 1.39 0 0 0 1.364 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.15c2.911 0 5.364-.318 7.286-.944c1.978-.642 3.797-1.731 5.408-3.238a16.52 16.52 0 0 0 3.258-4.086c.832-1.487 1.428-3.147 1.775-4.931c.86-4.423.162-7.964-2.076-10.524c-2.216-2.537-5.697-3.823-10.35-3.823zM87.666 68.557h4.47c2.964 0 5.17-.557 6.622-1.675c1.45-1.116 2.428-2.98 2.936-5.591c.487-2.508.266-4.277-.665-5.308c-.93-1.03-2.791-1.546-5.583-1.546h-5.035Zm10.563-19.445c4.251 0 7.354 1.117 9.303 3.348c1.95 2.232 2.537 5.347 1.759 9.346c-.32 1.648-.862 3.154-1.624 4.518c-.763 1.366-1.76 2.614-2.992 3.747c-1.467 1.373-3.097 2.352-4.892 2.935c-1.793.584-4.078.875-6.856.875h-6.295l-1.745 8.97h-7.35l6.558-33.739h14.133"/><defs><radialGradient id="deviconPhp0" cx="0" cy="0" r="1" gradientTransform="translate(38.426 42.169) scale(84.04136)" gradientUnits="userSpaceOnUse"><stop stopColor="#AEB2D5"/><stop offset=".3" stopColor="#AEB2D5"/><stop offset=".75" stopColor="#484C89"/><stop offset="1" stopColor="#484C89"/></radialGradient></defs></svg>
}
        href="/sdks/php"
      >
        Connect your PHP app to Novu via the PHP SDK.
      </Card>

      <Card title="Laravel" icon="laravel" href="/sdks/laravel">
        Connect your Laravel app to Novu via the Laravel SDK.
      </Card>

      <Card
        title=".NET"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 256 256"><g fill="none"><rect width="256" height="256" fill="#512BD4" rx="60"/><path fill="#fff" d="M24.052 168.943c-2.236 0-4.138-.731-5.703-2.194c-1.566-1.501-2.349-3.283-2.349-5.347c0-2.101.783-3.902 2.349-5.403c1.565-1.5 3.466-2.251 5.703-2.251c2.274 0 4.194.751 5.76 2.251c1.603 1.501 2.404 3.302 2.404 5.403c0 2.064-.801 3.846-2.404 5.347c-1.566 1.463-3.486 2.194-5.76 2.194Zm89.415-1.238H98.929l-38.304-59.318a26.371 26.371 0 0 1-2.404-4.672h-.336c.298 1.726.447 5.422.447 11.087v52.903H45.471V87H60.96l37.018 57.912c1.566 2.402 2.572 4.052 3.02 4.953h.223c-.372-2.139-.559-5.759-.559-10.863V87h12.805v80.705Zm62.631 0h-45.014V87h43.225v11.369h-29.916v22.849h27.568v11.312h-27.568v23.863h31.705v11.312Zm63.973-69.336h-23.038v69.336h-13.309V98.369h-22.982V87h59.329v11.369Z"/></g></svg>
}
        href="/sdks/dotnet"
      >
        Connect your C#/.NET app to Novu via the .NET SDK.
      </Card>

      <Card
        title="Ruby"
        icon={
       <svg xmlns="http://www.w3.org/2000/svg" width="20" height="19.93" viewBox="0 0 256 255"><defs><linearGradient id="logosRuby0" x1="84.75%" x2="58.254%" y1="111.399%" y2="64.584%"><stop offset="0%" stopColor="#FB7655"/><stop offset="0%" stopColor="#FB7655"/><stop offset="41%" stopColor="#E42B1E"/><stop offset="99%" stopColor="#900"/><stop offset="100%" stopColor="#900"/></linearGradient><linearGradient id="logosRuby1" x1="116.651%" x2="1.746%" y1="60.89%" y2="19.288%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby2" x1="75.774%" x2="38.978%" y1="219.327%" y2="7.829%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby3" x1="50.012%" x2="66.483%" y1="7.234%" y2="79.135%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E57252"/><stop offset="46%" stopColor="#DE3B20"/><stop offset="99%" stopColor="#A60003"/><stop offset="100%" stopColor="#A60003"/></linearGradient><linearGradient id="logosRuby4" x1="46.174%" x2="49.932%" y1="16.348%" y2="83.047%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E4714E"/><stop offset="56%" stopColor="#BE1A0D"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby5" x1="36.965%" x2="49.528%" y1="15.594%" y2="92.478%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="18%" stopColor="#E46342"/><stop offset="40%" stopColor="#C82410"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby6" x1="13.609%" x2="85.764%" y1="58.346%" y2="-46.717%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="54%" stopColor="#C81F11"/><stop offset="99%" stopColor="#BF0905"/><stop offset="100%" stopColor="#BF0905"/></linearGradient><linearGradient id="logosRuby7" x1="27.624%" x2="50.745%" y1="21.135%" y2="79.056%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="31%" stopColor="#DE4024"/><stop offset="99%" stopColor="#BF190B"/><stop offset="100%" stopColor="#BF190B"/></linearGradient><linearGradient id="logosRuby8" x1="-20.667%" x2="104.242%" y1="122.282%" y2="-6.342%"><stop offset="0%" stopColor="#BD0012"/><stop offset="0%" stopColor="#BD0012"/><stop offset="7%" stopColor="#FFF"/><stop offset="17%" stopColor="#FFF"/><stop offset="27%" stopColor="#C82F1C"/><stop offset="33%" stopColor="#820C01"/><stop offset="46%" stopColor="#A31601"/><stop offset="72%" stopColor="#B31301"/><stop offset="99%" stopColor="#E82609"/><stop offset="100%" stopColor="#E82609"/></linearGradient><linearGradient id="logosRuby9" x1="58.792%" x2="11.964%" y1="65.205%" y2="50.128%"><stop offset="0%" stopColor="#8C0C01"/><stop offset="0%" stopColor="#8C0C01"/><stop offset="54%" stopColor="#990C00"/><stop offset="99%" stopColor="#A80D0E"/><stop offset="100%" stopColor="#A80D0E"/></linearGradient><linearGradient id="logosRubya" x1="79.319%" x2="23.088%" y1="62.754%" y2="17.888%"><stop offset="0%" stopColor="#7E110B"/><stop offset="0%" stopColor="#7E110B"/><stop offset="99%" stopColor="#9E0C00"/><stop offset="100%" stopColor="#9E0C00"/></linearGradient><linearGradient id="logosRubyb" x1="92.88%" x2="59.841%" y1="74.122%" y2="39.704%"><stop offset="0%" stopColor="#79130D"/><stop offset="0%" stopColor="#79130D"/><stop offset="99%" stopColor="#9E120B"/><stop offset="100%" stopColor="#9E120B"/></linearGradient><linearGradient id="logosRubyc" x1="56.57%" x2="3.105%" y1="101.717%" y2="11.993%"><stop offset="0%" stopColor="#8B2114"/><stop offset="0%" stopColor="#8B2114"/><stop offset="43%" stopColor="#9E100A"/><stop offset="99%" stopColor="#B3100C"/><stop offset="100%" stopColor="#B3100C"/></linearGradient><linearGradient id="logosRubyd" x1="30.87%" x2="92.471%" y1="35.599%" y2="100.694%"><stop offset="0%" stopColor="#B31000"/><stop offset="0%" stopColor="#B31000"/><stop offset="44%" stopColor="#910F08"/><stop offset="99%" stopColor="#791C12"/><stop offset="100%" stopColor="#791C12"/></linearGradient><radialGradient id="logosRubye" cx="32.001%" cy="40.21%" r="69.573%" fx="32.001%" fy="40.21%"><stop offset="0%" stopColor="#A80D00"/><stop offset="0%" stopColor="#A80D00"/><stop offset="99%" stopColor="#7E0E08"/><stop offset="100%" stopColor="#7E0E08"/></radialGradient><radialGradient id="logosRubyf" cx="13.549%" cy="40.86%" r="88.386%" fx="13.549%" fy="40.86%"><stop offset="0%" stopColor="#A30C00"/><stop offset="0%" stopColor="#A30C00"/><stop offset="99%" stopColor="#800E08"/><stop offset="100%" stopColor="#800E08"/></radialGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby0)" d="m197.467 167.764l-145.52 86.41l188.422-12.787L254.88 51.393l-57.414 116.37Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby1)" d="M240.677 241.257L224.482 129.48l-44.113 58.25l60.308 53.528Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby2)" d="m240.896 241.257l-118.646-9.313l-69.674 21.986l188.32-12.673Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby3)" d="m52.744 253.955l29.64-97.1L17.16 170.8l35.583 83.154Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby4)" d="M180.358 188.05L153.085 81.226l-78.047 73.16l105.32 33.666Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby5)" d="m248.693 82.73l-73.777-60.256l-20.544 66.418l94.321-6.162Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby6)" d="M214.191.99L170.8 24.97L143.424.669l70.767.322Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby7)" d="m0 203.372l18.177-33.151l-14.704-39.494L0 203.372Z"/><path fill="#FFF" d="m2.496 129.48l14.794 41.963l64.283-14.422l73.39-68.207l20.712-65.787L143.063 0L87.618 20.75c-17.469 16.248-51.366 48.396-52.588 49c-1.21.618-22.384 40.639-32.534 59.73Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby8)" d="M54.442 54.094c37.86-37.538 86.667-59.716 105.397-40.818c18.72 18.898-1.132 64.823-38.992 102.349c-37.86 37.525-86.062 60.925-104.78 42.027c-18.73-18.885.515-66.032 38.375-103.558Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRuby9)" d="m52.744 253.916l29.408-97.409l97.665 31.376c-35.312 33.113-74.587 61.106-127.073 66.033Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubya)" d="m155.092 88.622l25.073 99.313c29.498-31.016 55.972-64.36 68.938-105.603l-94.01 6.29Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyb)" d="M248.847 82.833c10.035-30.282 12.35-73.725-34.966-81.791l-38.825 21.445l73.791 60.346Z"/><path fill="#9E1209" d="M0 202.935c1.39 49.979 37.448 50.724 52.808 51.162l-35.48-82.86L0 202.935Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubye)" d="M155.232 88.777c22.667 13.932 68.35 41.912 69.276 42.426c1.44.81 19.695-30.784 23.838-48.64l-93.114 6.214Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyf)" d="m82.113 156.507l39.313 75.848c23.246-12.607 41.45-27.967 58.121-44.42l-97.434-31.428Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyc)" d="m17.174 171.34l-5.57 66.328c10.51 14.357 24.97 15.605 40.136 14.486c-10.973-27.311-32.894-81.92-34.566-80.814Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosRubyd)" d="m174.826 22.654l78.1 10.96c-4.169-17.662-16.969-29.06-38.787-32.623l-39.313 21.663Z"/></svg>

}
        href="/sdks/ruby"
      >
        Connect your Ruby app to Novu via the Ruby SDK.
      </Card>

      <Card
        title="Java"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="#0074BD" d="M47.617 98.12s-4.767 2.774 3.397 3.71c9.892 1.13 14.947.968 25.845-1.092c0 0 2.871 1.795 6.873 3.351c-24.439 10.47-55.308-.607-36.115-5.969zm-2.988-13.665s-5.348 3.959 2.823 4.805c10.567 1.091 18.91 1.18 33.354-1.6c0 0 1.993 2.025 5.132 3.131c-29.542 8.64-62.446.68-41.309-6.336z"/><path fill="#EA2D2E" d="M69.802 61.271c6.025 6.935-1.58 13.17-1.58 13.17s15.289-7.891 8.269-17.777c-6.559-9.215-11.587-13.792 15.635-29.58c0 .001-42.731 10.67-22.324 34.187z"/><path fill="#0074BD" d="M102.123 108.229s3.529 2.91-3.888 5.159c-14.102 4.272-58.706 5.56-71.094.171c-4.451-1.938 3.899-4.625 6.526-5.192c2.739-.593 4.303-.485 4.303-.485c-4.953-3.487-32.013 6.85-13.743 9.815c49.821 8.076 90.817-3.637 77.896-9.468zM49.912 70.294s-22.686 5.389-8.033 7.348c6.188.828 18.518.638 30.011-.326c9.39-.789 18.813-2.474 18.813-2.474s-3.308 1.419-5.704 3.053c-23.042 6.061-67.544 3.238-54.731-2.958c10.832-5.239 19.644-4.643 19.644-4.643zm40.697 22.747c23.421-12.167 12.591-23.86 5.032-22.285c-1.848.385-2.677.72-2.677.72s.688-1.079 2-1.543c14.953-5.255 26.451 15.503-4.823 23.725c0-.002.359-.327.468-.617z"/><path fill="#EA2D2E" d="M76.491 1.587S89.459 14.563 64.188 34.51c-20.266 16.006-4.621 25.13-.007 35.559c-11.831-10.673-20.509-20.07-14.688-28.815C58.041 28.42 81.722 22.195 76.491 1.587z"/><path fill="#0074BD" d="M52.214 126.021c22.476 1.437 57-.8 57.817-11.436c0 0-1.571 4.032-18.577 7.231c-19.186 3.612-42.854 3.191-56.887.874c0 .001 2.875 2.381 17.647 3.331z"/></svg>
}
        href="/sdks/java"
      >
        Connect your Java app to Novu via the Java SDK.
      </Card>

      <Card
        title="Kotlin"
        icon={
  <svg
    xmlns="http://www.w3.org/2000/svg"
    width="20"
    height="20"
    viewBox="0 0 256 256"
  >
    <defs>
      <linearGradient
        id="logosKotlinIcon0"
        x1="99.991%"
        x2=".01%"
        y1="-.011%"
        y2="100.01%"
      >
        <stop offset=".344%" stopColor="#E44857" />
        <stop offset="46.89%" stopColor="#C711E1" />
        <stop offset="100%" stopColor="#7F52FF" />
      </linearGradient>
    </defs>
    <path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosKotlinIcon0)" d="M256 256H0V0h256L128 127.949z" />
  </svg>
}
        href="/sdks/kotlin"
      >
        Connect your Kotlin app to Novu via the Kotlin SDK.
      </Card>

      <Card
        title="Python"
        icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="34.87" viewBox="0 0 256 255"><defs><linearGradient id="logosPython0" x1="12.959%" x2="79.639%" y1="12.039%" y2="78.201%"><stop offset="0%" stopColor="#387EB8"/><stop offset="100%" stopColor="#366994"/></linearGradient><linearGradient id="logosPython1" x1="19.128%" x2="90.742%" y1="20.579%" y2="88.429%"><stop offset="0%" stopColor="#FFE052"/><stop offset="100%" stopColor="#FFC331"/></linearGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosPython0)" d="M126.916.072c-64.832 0-60.784 28.115-60.784 28.115l.072 29.128h61.868v8.745H41.631S.145 61.355.145 126.77c0 65.417 36.21 63.097 36.21 63.097h21.61v-30.356s-1.165-36.21 35.632-36.21h61.362s34.475.557 34.475-33.319V33.97S194.67.072 126.916.072ZM92.802 19.66a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.13Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/getting-started#logosPython1)" d="M128.757 254.126c64.832 0 60.784-28.115 60.784-28.115l-.072-29.127H127.6v-8.745h86.441s41.486 4.705 41.486-60.712c0-65.416-36.21-63.096-36.21-63.096h-21.61v30.355s1.165 36.21-35.632 36.21h-61.362s-34.475-.557-34.475 33.32v56.013s-5.235 33.897 62.518 33.897Zm34.114-19.586a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.131a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13Z"/></svg>
}
        href="/sdks/python"
      >
        Connect your Python app to Novu via the Python SDK.
      </Card>
    </CardGroup>
  </Accordion>
</AccordionGroup>

The [Novu Cloud SaaS](https://web.novu.co) platform provides an intuitive internal user interface, embeddable UI end-user components, and a hybrid code-first workflow capability.

Novu eliminates the significant burden of building, hosting, and managing a notifications infrastructure that all modern software businesses need in order to notify and engage staff, end users, and customers.

## Notification types

Novu supports different notification types, including user-generated and machine-generated notifications.

### Machine generated

* Triggered by some automated action—think a container pod scaling event.
* Notify one or more end users (which can be internal users, of course!).
* Often can be voluminous, so digests are helpful.

### Product notifications

* Triggered by end-user interactions and events within your product.
* Notify one or more subscribers.
* Typically transactional, such as order updates, password resets, account verifications, or login/OTP codes.
* Can also be used to provide product updates, such as new features or bug fixes.

### Promotional notifications

* Centered on promoting products, services, or events.
* Can be used to generate leads, increase sales, or drive engagement.

### Key Differences

* Product notifications are triggered by user activity, while promotional notifications are sent at the discretion of the marketer.
* Product notifications are typically more transactional in nature, while promotional notifications are more marketing-oriented.
* Product notifications are often sent to all subscribers, while promotional notifications can be targeted to specific audiences.

## Notification channels

Novu supports all major notification channels, and integrates with multiple delivery providers for each one. Each channel can use the same source notification content, as desired.

* [Email](/channels-and-providers/email/overview)
* [Push](/channels-and-providers/push/overview)
* [SMS](/channels-and-providers/sms/overview)
* [Chat](/channels-and-providers/chat/overview)
* [In-App](/channels-and-providers/in-app/introduction)

## Who is Novu for?

How you use and get started with Novu depends on your role. While it’s implemented initially by engineering and development teams, Novu unifies everyone in an organization that authors, creates, sends, manages and measures results from notifications being sent to end users. Novu empowers engineers to deliver notification platforms for product teams.

### Novu for developers and engineering teams

Novu empowers developers and engineering teams to quickly deliver a fully extensible notifications platform for product teams to create captivating notification experiences.

We provide the following proven stack for developers to simply integrate into their products:

* **[Unified API](/api-reference/overview)  & [SDK clients](/sdks/introduction)** for managing all channels and platforms across multiple programming languages.
* **[Prebuilt, customisable UI components](/notification-center/introduction#ui-libraries)** for in-app user notification feeds and preference experiences.
* **[Integration with multiple delivery providers](/channels-and-providers/introduction)**, allowing you to continue using your preferred vendors with Novu.
* **[Scalable, reliable Novu Cloud SaaS infrastructure](https://web.novu.co)** developed from scratch to meet the demands of high-volume notification delivery and storage (think hundreds of millions of notifications).
* **[Observability](/activity-feed/introduction)** for delving into the lifecycle of notification’s success or failure.  Eliminate guesswork of how, when, and why a user receives a notification.
* **Comprehensive documentation**, implementation guides, recipes and illustrative examples.
* **Compliance and security** for safely managing your data.
* **Open source** based provides trust, generates significant community input, and enables you to deploy and self-host a Novu Project instance into any environment of your choosing.

Notification content can be written in a variety of common content tooling, including [React](/framework/integrations/react-email), [Vue-email](/framework/integrations/vue-email), [MJML](/guides/framework-guides/framework-mjml), and more. Content can also be customized and hydrated using any datasource.

### Novu for product teams

We are well aware of the friction that often exists between engineering and product teams, and have built features that allow product teams to customize notification experiences easily and safely—without risking disrupting or breaking important integrations and logic.

Product teams can craft beautiful notification content and campaigns in any content framework of their choice.

* They can modify and manage notification UIs that engineers have built via Novu workflows.
* They gain valuable insights into user engagement with notifications via logs and analytics.
* They can use their preferred notification content editors.
* They can focus on crafting impactful notification content while engineers

### Novu for end users

When implemented, most end users will not be aware that it’s Novu behind the scenes, other than that they now receive notifications where and when they expect them.

The [Novu Notification Center](/notification-center/introduction) is an embeddable component that when included in your app, enables users to view and set their own notification preferences, including channel, preferred language, and more.

Novu ensures fast delivery and beautiful notification experiences for end users regardless of the channels involved.

With Novu, your app users receive instant notifications via **email**, **in-app alerts**, **SMS**, **push notifications**, and **chat**.

## Use Cases

Novu is heavily customizable, and can tackle nearly any notification requirement, no matter how simple or complex. These are some of the more common use cases:

* **Manage multiple notification providers:** Novu empowers you to manage all your notification delivery providers across email, SMS, push and chat in one place. Developers can add new notification providers across different channels without changing the app codebase.
* **Centralize legacy notification systems:** Reduce notification complexity, unify management and visibility into one platform.
* **Centralized debugging of notifications across multiple channels**: Novu allows you understand and debug notifications sent across different channels in one place.
* **In-app Notification Center:** Novu provides a real-time embedded notification center widget that can simply be dropped into any web application to enable end users to manage their own notification preferences.
* **Notification personalization:** Novu provides a user preferences feature that gives your end users a say in how they want to receive notifications.
* **Notification content management:** Novu provides the ability to integrate any content framework and tool of your choice to manage notification content across teams.
* **Send notifications in users language of choice**: Novu allows you to send notifications in preferred users language. App and notification internalization increases users engagement and retention in your product.
* **Reduce notification alert fatigue**: Novu prevents notification fatigue by providing the ability to batch multiple notifications and send as one to subscribers (end users). Leverage Novu in digesting multiple notification events.


# Sign Up on Novu Cloud
Source: https://v0.x-docs.novu.co/getting-started/novu-sign-up

Sign up to our managed service

## Introduction

Novu’s aim is to simplify sending notifications across platforms. As such, we provide simple components, APIs, SDKs and more to help you manage product communication across channels.

This comprehensive guide will help you kickstart your journey with Novu and get your hands dirty!

Everything you need to get up and running successfully can be found here. Let’s begin!

## Signing up to Novu Cloud

Novu Cloud is our managed service that lets you oversee all aspects of your product communication from a user-friendly web dashboard. With Novu Cloud, you can handle various communication channels, create and manage workflows, switch organizations and monitor your activity, ensuring that you get comprehensive control over your product communication and that your message reaches your customers effectively.

To be able to do this and a lot more, you need to sign up for Novu Cloud:

1. Head to [Novu Cloud](https://web.novu.co/auth/signup?utm_campaign=docs-gs-signup). You’ll see this:

<Frame>
  <img />
</Frame>

2. To sign up, you can either use your email and password or sign up using Github. Choose what you wish to proceed with, read the terms and conditions, check its checkbox and click the sign-up button.

<Frame>
  <img />
</Frame>

3. You’ll then be asked to create an Organization. Organizations help you segregate communication between your different products. You can learn more about organisations here. Simply enter your organization name and click on the ‘create’ button:

<Frame>
  <img />
</Frame>

4. On creating an organization, you’ll be greeted with the get started page:

<Frame>
  <img />
</Frame>

This gives you access to a lot of options:

<Frame>
  <img />
</Frame>

1. Accessing support
2. Managing your account
3. Configuring different channels
4. Navigating to any other sections of the dashboard

From here, you can navigate to any part of the web dashboard. Let’s now see Novu in action!


# Send Your First Notification
Source: https://v0.x-docs.novu.co/getting-started/send-your-first-notification

Learn how to send your first notification via the Novu Cloud dashboard.

Sending the first notification is fairly simple, and can be done from within the web dashboard. To send your first notification, follow these steps:

## Workflow for Email notifications

1. Navigate to the workflow section from the left sidebar:

   <Frame>
     <img />
   </Frame>

2. Click on the `Blank Workflow` button to create an empty workflow:

   <Frame>
     <img />
   </Frame>

3. You are now in the workflow editor. Here you can add steps to your workflow. We’ll just drag the email node from the right sidebar to our workflow as illustrated below:

   <Frame>
     <img />
   </Frame>

4. Now, simply click on the email node, and add the subject and the notification
   text in the email node editor:

   <Frame>
     <img />
   </Frame>

5. Now, update the workflow and save it as shown in the image below:

   <Frame>
     <img />
   </Frame>

6. Now, to execute this workflow, click on the `get snippet` button from the workflow editor:

   <Frame>
     <img />
   </Frame>

7. From the `run a test` tab, you can change the email to which you want the notification. Once you’ve done that, simply click on the `Run Trigger` button on the bottom right:

   <Frame>
     <img />
   </Frame>

8. Now, go to the inbox and you’ll see the email notification there. Don’t forget also to check spam as it may sometimes land in there:

   <Frame>
     <img />
   </Frame>

9. This gif below captures the entire process:

   <Frame>
     <img />
   </Frame>

## Workflow for In-App notifications

Creating workflows for sending in-app notifications is pretty straightforward. Just follow the following steps and you'll be good to go:

1. Head to `workflows` on the [Novu web dashboard](https://web.novu.co/workflows?utm_campaign=docs-gs-sendfirstnotification).

   <Frame>
     <img />
   </Frame>

2. Click on the Blank Workflow button to create a workflow from scratch.

   <Frame>
     <img />
   </Frame>

<Note>
  If you want to avoid creating a workflow from scratch, then instead of
  choosing `Blank Workflow`, select `All Templates` and you'll find a bunch of
  workflow templates that you can customize and use:

  <Frame>
    <img />
  </Frame>

  <br />

  <Frame>
    <img />
  </Frame>
</Note>

3. You'll now end up in the workflow editor. Workflow editor, as the name suggests, is the place from where you can edit workflows. You can select which [channels](/channels-and-providers/introduction#channels) you want to send notifications in, add [digest](/guides/add-digest-to-inapp-notifications) to your in-app notifications and more.

   <Frame>
     <img />
   </Frame>

4. For your use case here, we'll simply add an `in-app` node to our workflow.

   <Note>
     Don't forget to rename your workflow to an appropriate name.

     <Frame>
       <img />
     </Frame>
   </Note>

5. Now, the `in-app` node has a lot of options for you to configure:

   <Frame>
     <img />
   </Frame>

* **Preview**: This shows you a glimpse of what each notification item will look like in the Notification Center UI.
* **Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.

6. In this editor, you need to plug in the variable that your backend is expecting in the payload:

   <Frame>
     <img />
   </Frame>

7. You can even use [handlebars](/content-creation-design/handlebars-helpers) to further customise this.

8. Once you're done configuring it, simply click the `update` button on the top right corner.

   <Frame>
     <img />
   </Frame>

9. Now, simply click on the `Get Snippet` button to get the trigger code snippet.

   <Frame>
     <img />
   </Frame>

10. You'll get the code that you need to plug into your backend to be executed whenever an event fires.

    <Frame>
      <img />
    </Frame>

    <br />

    <Warning>
      Don't forget to use your actual `API_KEY` and `subscriberId`.
    </Warning>

That's it, you've successfully built a workflow for sending in-app notifications!

## Workflow for SMS notifications

SMS workflows are not very different from [email](/getting-started/send-your-first-notification#workflow-for-email-notifications) and [in-app](localhost:3001/getting-started/send-your-first-notification#workflow-for-in-app-notifications) workflows we've created above. Let's take a look at it:

1. Head to `Workflows` on the [Novu web dashboard.](https://web.novu.co/workflows?utm_campaign=docs-gs-sendfirstnotification)

   <Frame>
     <img />
   </Frame>

2. Click on the `Blank Workflow` button to create a workflow from scratch.

   <Frame>
     <img />
   </Frame>

<Note>
  If you want to avoid creating a workflow from scratch, then instead of
  choosing `Blank Workflow`, select `All Templates` and you'll find a bunch of
  workflow templates that you can customize and use:

  <Frame>
    <img />
  </Frame>

  <br />

  <Frame>
    <img />
  </Frame>
</Note>

3. You'll now end up in the workflow editor. Workflow editor, as the name suggests, is the place from where you can edit workflows. You can select which [channels](/channels-and-providers/introduction#channels) you want to send notifications in, add [digest](/guides/add-digest-to-inapp-notifications) to your in-app notifications and more.

   <Frame>
     <img />
   </Frame>

4. Since we're creating a workflow for SMS notifications, we'll drag the `SMS` step to our workflow, as shown in this picture below:

   <Frame>
     <img />
   </Frame>

5. If you hover over the SMS node, you will get a message saying 'Required - SMS content\`. Click on the SMS node and add a message to it. This is what will be sent as a notification in the SMS.

   <Frame>
     <img />
   </Frame>

   <br />

   <Note>
     Instead of having static messages, you can have your notifications be
     dynamic by using `handlebars`. Take a look
     [here](/content-creation-design/handlebars-helpers) for more. If your
     backend is expecting data in the payload, plug that variable here in double
     braces.
   </Note>

6. Once you’re done configuring it, simply click the update button on the top right corner.

   <Frame>
     <img />
   </Frame>

7. Now, simply click on the Get Snippet button to get the trigger code snippet.

   <Frame>
     <img />
   </Frame>

8. You’ll get the code that you need to plug into your backend to be executed whenever an event fires.

   <Frame>
     <img />
   </Frame>

   <Warning>Don’t forget to use your actual API\_KEY and subscriberId.</Warning>
   That’s it, you’ve successfully built a workflow for sending in-app
   notifications!

## Workflow for Chat notifications

Chat workflows are quite similar to [email](/getting-started/send-your-first-notification#workflow-for-email-notifications), [in-app](localhost:3001/getting-started/send-your-first-notification#workflow-for-in-app-notifications), and [SMS workflows](/getting-started/send-your-first-notification#workflow-for-sms-notifications) workflows we've created above. Let's take a look at it in detail:

1. Head to `Workflows` on the [Novu web dashboard.](https://web.novu.co/workflows?utm_campaign=docs-gs-sendfirstnotification)

   <Frame>
     <img />
   </Frame>

2. Click on the `Blank Workflow` button to create a workflow from scratch.

   <Frame>
     <img />
   </Frame>

   <br />

   <Note>
     If you want to avoid creating a workflow from scratch, then instead of
     choosing `Blank Workflow`, select `All Templates` and you'll find a bunch
     of workflow templates that you can customize and use:

     <Frame>
       <img />
     </Frame>

     <br />

     <Frame>
       <img />
     </Frame>
   </Note>

3. You'll now end up in the workflow editor. Workflow editor, as the name suggests, is the place from where you can edit workflows. You can select which [channels](/channels-and-providers/introduction#channels) you want to send notifications in, add [digest](/guides/add-digest-to-inapp-notifications) to your in-app notifications and more.

   <Frame>
     <img />
   </Frame>

4. Just add this `Chat` node to the workflow.

   <Frame>
     <img />
   </Frame>

5. In the `Chat` node, you can enter the notification message. This is what will get sent to the [subscriber](/subscribers/subscribers) as a notification. If you're sending dynamic messages, use the variable that is expected in your payload in double braces here. Using [handlebars](/content-creation-design/handlebars-helpers), you can further extend this functionality.

   <Frame>
     <img />
   </Frame>

6. Once you’re done configuring it, simply click the update button on the top right corner.

   <Frame>
     <img />
   </Frame>

7. Now, simply click on the Get Snippet button to get the trigger code snippet.

   <Frame>
     <img />
   </Frame>

8. You’ll get the code that you need to plug into your backend to be executed whenever an event fires.

   <Frame>
     <img />
   </Frame>

   <Warning>Don’t forget to use your actual API\_KEY and subscriberId.</Warning>
   That’s it, you’ve successfully built a workflow for sending chat notifications!

Don't forget to check out our [guides](/guides/add-digest-to-inapp-notifications) and [demo apps](/demos/introduction) for more information on specific features.


# .NET
Source: https://v0.x-docs.novu.co/quickstarts/.NET

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with .NET.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications from a .NET app.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-dotnet) if you don’t have one yet.
* A working .NET development environment with a .NET version of .NET Core 2.0+ and .NET Framework of 4.6.1+.

You can also [view the completed code](https://github.com/novuhq/novu-dotnet-quickstart) of this quick start in a GitHub repo.

## Install Novu .NET SDK

The [.NET SDK](https://github.com/novuhq/novu-dotnet) provides a fluent and expressive interface for interacting with Novu's API and managing notifications.

Now install the Novu .NET SDK by running the following command in your terminal:

```bash theme={null}
dotnet add package Novu

```

Otherwise, modify your .csproj file add the following to it:

```xml theme={null}
<ItemGroup>
    <PackageReference Include="Novu" Version="*" />
</ItemGroup>

```

Next, install the SDK by running the following `dotnet` command:

```bash theme={null}
dotnet restore

```

## Initialize & Configure the Novu SDK

Create a new file, `Program.cs` in your application and add the following code to it:

Program.cs:

```csharp theme={null}
using Novu.DTO;
using Novu.DTO.Topics;
using Novu.Models;
using Novu;

 var novuConfiguration = new NovuClientConfiguration
{
    ApiKey = "<NOVU_API_KEY>",
};

var novu = new NovuClient(novuConfiguration);
```

Replace the `ApiKey`’s value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-dotnet) and be sure to use your specific Novu instance URL.

<Note>
  Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-dotnet) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favourite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create A Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **Untitled.** Rename it to a more suitable title.
4. Select **Email** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

6. Click on the “Test” tab and send a test email to verify your workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. Yaaay, you have successfully sent your first notification via the Novu dashboard! Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click “Subscribers” on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```csharp theme={null}
// Create subscriber

var newSubscriberDto = new SubscriberCreateData
{
  SubscriberId = "77809", //replace with system_internal_user_id
  FirstName = "John",
  LastName = "Doe",
  Email = "benlin1994@gmail.com",
  Data = new List<AdditionalDataDto>{
    new AdditionalDataDto
    {
        Key = "External ID",
        Value = "1122334455"
    },
    new AdditionalDataDto
    {
        Key = "Job Title",
        Value = "Software Engineer"
    }
  }
};

var subscriber = await novu.Subscriber.Create(newSubscriberDto);
```

Run the code in your terminal like so:

```bash theme={null}
dotnet run Program.cs

```

You should see the subscriber on your Novu dashboard.

<Frame>
  <img />
</Frame>

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `UpdateSubscriber` method like so:

Program.cs:

```csharp theme={null}
// Update subscriber detail
var subscriber7789 = await novu.Subscriber.GetSubscriber("7789");

subscriber7789.Email = "validemail@gmail.com"; // replace with valid email
subscriber7789.FirstName = "<insert-firstname>"; // optional
subscriber7789.LastName = "<insert-lastname>"; // optional

var updatedSubscriber = await novu.Subscriber.Update("7789",subscriber7789);
```

Other valid fields that can be updated are `phone`, `avatar`, and `data` . The `data` field can accept an array of metadata that you want to attach to the subscriber.

<Note>
  To make all of your app users subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

OnboardEventPayload.cs:

```csharp theme={null}
// OnboardEventPayload.cs
public class OnboardEventPayload
{
  [JsonProperty("username")]
  public string Username { get; set; }

  [JsonProperty("welcomeMessage")]
  public string WelcomeMessage { get; set; }
}

```

Program.cs:

```csharp theme={null}
var onboardingMessage = new OnboardEventPayload
{
  Username = "jdoe",
  WelcomeMessage = "Welcome to novu-dotnet"
};

var payload = new EventCreateData()
{
  EventName = "onboarding", //make sure you have a trigger named "onboarding"
  To = { SubscriberId = "7789" },
  Payload = onboardingMessage
};

var trigger = await novu.Event.Trigger(payload);

if (trigger.Data.Acknowledged)
{
  Console.WriteLine("Trigger has been created.");
}

```

Before running the code, make sure you understand the following:

* The value of `EventName` should be the workflow’s trigger ID/slug(it's the value all in small caps).

<Frame>
  <img />
</Frame>

* The value of `Payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `SubscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriberId.

Run the code to trigger a notification!

```bash theme={null}
dotnet run Program.cs

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safeguards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```csharp theme={null}
// Create Topic
var topicRequest = new TopicCreateData
{
    Key = "frontend-users",
    Name = "All frontend users",

};

var topic = await novu.Topic.Create(topicRequest);
```

Before running the code, make sure you understand the following:

* When creating a `Key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `Name` should be a descriptive topic name.

## Add Subscribers to a Topic

Copy and paste the following code into your app to add subscribers to a topic:

```csharp theme={null}

// Add Subscriber to Topic
var topicKey = "frontend-users";
var subscriberList = new TopicSubscriberUpdateDto
{
    Keys = new List<string>
    {
        "7789",
        "7790",
    }
};

//Or

var subscriberList = new TopicSubscriberCreateData(new List<string>
{
    "7789",
    "7790"
});

var result = await novu.Topic.AddSubscriber(topicKey, subscriberList);
```

## Sending a Notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

Program.cs

```csharp theme={null}
// Send notifications to a topic (all frontend users)

var onboardingMessage = new OnboardEventPayload
{
  WelcomeMessage = "Welcome to novu-dotnet"
};

var payloadTopic = new EventTopicTriggerDto
{
  EventName = "onboarding",
  Payload = onboardingMessage,
  Topic = { Type = "7789", TopicKey = "frontend-users" },

};

var triggerTopic = await novu.Event.TriggerTopicAsync(payloadTopic);

if (triggerTopic.TriggerResponsePayloadDto.Acknowledged);
{
  Console.WriteLine("Trigger has been created.");
}

```

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider and triggered a notification in your application.


# Angular
Source: https://v0.x-docs.novu.co/quickstarts/angular

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Angular.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications and integrate a rich, customizable and ready-to-use real-time UI In-App notification center in Angular apps.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-angluar) if you don’t have one yet
* Angular CLI (Command Line Interface) installed on your machine
* Angular version 15 or higher

You can also [view the completed code](https://github.com/novuhq/angular-quickstart) of this quick start in a GitHub repo.

## Create a new Angular app

To create a new Angular app, open a terminal or command prompt and  run the following command:

```bash theme={null}
ng new my-app
```

Here, `my-app` is the name of your new Angular app.  This command will create a new Angular app with a basic file structure and all the necessary dependencies installed.

Navigate to the app directory by running the following command:

```bash theme={null}
cd my-app
```

Once you are in the app directory, you can start the development server by running the following command:

```bash theme={null}
ng serve
```

This command will start the development server and launch your app in the default browser. You can access your app by navigating to `http://localhost:4200/`.

<Frame>
  <img />
</Frame>

## Install Novu Angular Notification Center Package

The Novu Angular package provides a Angular component wrapper over the web component that you can use to integrate the notification center into your Angular application.

Navigate to the root directory of your Angular application. Now install the Angular Notification Center package by running the following command in your terminal:

<CodeGroup>
  ```bash pnpm theme={null}
  pnpm i @novu/notification-center-angular
  ```

  ```bash npm theme={null}
  npm i @novu/notification-center-angular
  ```

  ```bash yarn theme={null}
  yarn add @novu/notification-center-angular
  ```
</CodeGroup>

## Configuring Application Environments

Using the Angular CLI, start by running the [generate environments command](https://angular.io/cli/generate#environments-command)
shown here to create the `src/environments/`directory and configure the  project to use these files.

```bash theme={null}
ng generate environments
```

Navigate to `my-app/src/environments/environment.ts`  and add the following variables: `subscriberId`, `applicationIdentifier`

* **`applicationIdentifier`** can be found here: [https://web.novu.co/settings](https://web.novu.co/settings)
* **`subscriberId`** can be found here: [https://web.novu.co/subscribers](https://web.novu.co/subscribers)

```tsx theme={null}
export const environment = {
  production: false,
  subscriberId: '',
  applicationIdentifier: '',
};
```

Copy and paste the same code into `my-app/src/environments/environment.development.ts`

These variables are needed for the `GET` request our notification center will make to Novu’s API to push notifications into the feed.

## Adding Novu Module

Now, navigate to the `app.module.ts` file `(my-app/src/app/app.module.ts)`

* Import `CUSTOM_ELEMENTS_SCHEMA` from `'@angular/core'`
* Add Novu’s notification center module

```jsx theme={null}
import { CUSTOM_ELEMENTS_SCHEMA, NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { AppComponent } from './app.component';
import { NotificationCenterModule } from '@novu/notification-center-angular';

@NgModule({
  declarations: [AppComponent],
  imports: [BrowserModule, NotificationCenterModule],
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
  providers: [],
  bootstrap: [AppComponent],
})
export class AppModule {}
```

Head to `my-app/src/app/app.component.ts` file.

⚠️ The `app.component.ts` file is a critical part of an Angular application, as it  defines the root component and provides the foundation for the rest of  the app's functionality.

Now, we are going to import the `environment` variables to make them accessible in the `app.component.html` and the `styles` properties of our notification center

(there are many properties, but you can discover them later on)

```tsx theme={null}
import { Component } from '@angular/core';
import { environment } from '../environments/environment';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css'],
})
export class AppComponent {
  title = 'my-app';

  subscriberId = environment.subscriberId;
  applicationIdentifier = environment.applicationIdentifier;

  styles = {
    bellButton: {
      root: {
        svg: {
          color: 'white',
          width: '45px',
          height: '40px',
          fill: 'white',
        },
      },
      dot: {
        rect: {
          fill: 'rgb(221, 0, 49)',
          strokeWidth: '0.2',
          stroke: 'white',
          width: '3.5px',
          height: '3.5px',
        },
        left: '40%',
      },
    },
    header: {
      root: {
        backgroundColor: '',
        '&:hover': { backgroundColor: '' },
        '.some_class': { color: '' },
      },
    },
    layout: {
      root: {
        backgroundColor: '',
      },
    },
    popover: {
      arrow: {
        backgroundColor: '',
        border: '',
      },
    },
  };

  sessionLoaded = (data: unknown) => {
    console.log('loaded', { data });
  };
}
```

The Angular component is generated as a wrapper around the original React component. This approach is clever, as it allows Novu's engineers to focus on creating and developing things in the React way.

Additionally, many other frameworks can still use the created components using the wrapping approach.

Now head to the `my-app/tsconfig.json` file, we’re going to add `"allowSyntheticDefaultImports": true` to the `compilerOptions` array.

```diff theme={null}
{
  "compilerOptions": {
+   "allowSyntheticDefaultImports": true,
  }
}
```

## Use & Display The Notification Center Component

Open the `my-app/src/app/app.component.html` file.

This file contain the CSS code along with the HTML one - ideally you should separate the CSS to the `my-app/src/app/app.component.css` file, but it’s not mandatory.

We will add our notification center to the .toolbar div.

Paste the following into your `app.component.html` file:

```jsx theme={null}
  <div id="bell-icon">
    <notification-center-component
      [subscriberId]="subscriberId"
      [applicationIdentifier]="applicationIdentifier"
      [sessionLoaded]="sessionLoaded"
      [styles]="styles"
    ></notification-center-component>
  </div>
```

And in the `<style>` tag, we also want to add some margin to our `#bell-icon` so that it looks good next to the other icons.

```css theme={null}
.toolbar #bell-icon {
  height: '';
  margin: 0 16px;
}
```

Run your app again. Now you should see the bell icon (the notification center) in the toolbar section of your app.

You should now see a **bell button** that opens the notification center when clicked. This bell can be customized to your preference.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Note: There are no notifications because none has been triggered yet. When notifications are sent to a subscriber, it will show up in the UI. Next, we'll learn how to trigger notifications.

* [Angular Notification Center Example Repo](https://github.com/novuhq/examples/tree/main/novu-angular-notification-center)

## Create A Workflow

The first step to trigger notifications is to create a workflow. A workflow is like a map that holds the entire flow of messages sent to the subscriber.

The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **“Create Workflow”** button on the top right.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select **"In-App"** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added In-App channel and configure it according to your preferences. Once you’re done, click Update to save your configuration.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).

Feel free to add only text for now and rename the workflow to `Onboarding In App`. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Next, we’ll learn how to create subscribers on Novu - *Recipients of Notifications*

## Create A Subscriber

Click **Subscribers** on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-angluar) to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu.

Novu has a plethora of backend SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin) to choose from to create a subscriber programmatically. This is the recommended method.

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.identify('123', {
  firstName: 'Emil',
  lastName: 'Pearce',
  returnUser: true,
});
```

Obtain your API key from your [Novu dashboard.](https://web.novu.co/settings?utm_campaign=docs-quick-angluar) Replace `<NOVU_API_KEY>` with it.

Now check your Novu dashboard. You should see the recently created subscriber.

You can also update the subscriber info like so:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('123', {
  firstName: 'Emil', // new first name
  lastName: 'Pearce', // new last name
});
```

## Trigger A Notification

To trigger a notification, simply run the code below with the correct credentials.

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.trigger('onboarding-in-app', {
  to: {
    subscriberId: '132',
  },
});
```

`onboarding-in-app` is the workflow identifier we created earlier.

Ensure the `subscriberId` value in the backend code that triggers the notification matches the `subscriberId` in your `my-app/src/environments/environment.ts` code.

```jsx theme={null}
export const environment = {
  production: false,
  subscriberId: '',
  applicationIdentifier: '',
};
```

Check your app again. You should see the recently triggered notification!

## Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, configured a channel provider and triggered a notification in your Angular application.


# General
Source: https://v0.x-docs.novu.co/quickstarts/general

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications.

To create your free managed, or docker-based Novu environment use our CLI tool:

```
npx novu init
```

After creating your cloud or self-hosted account, the next steps to sending your first notification are outlined in this guide:

* Connect your providers
* Create a workflow
* Send a trigger
* Integrate the [Notification Center](https://docs.novu.co/notification-center/getting-started) within your app *(optional)*

# Connect providers

On the **Integration Store** page, you can configure the different providers and their respective credentials. During the alpha phase only a **single provider** is allowed **per channel**, adding a second email provider will de-activate the previously added email provider.

# Create a workflow

After configuring the designated channel provider, you can create your workflow. You can think of the workflow as the blueprint for the notifications that will be sent. The workflow includes:

* Workflow details
* Channel specific content
* Trigger definition

### Workflow Details

The **name** of the workflow is converted to a slug that is used as the trigger identifier which is used when sending the trigger from the back-end.

### Channel specific content

### Email

You can specify the content for emails in two ways:

**Visual workflow builder** - For simple use cases, you can use our visual workflow editor. The visual workflow builder has limited control over design but is easier to get-started with.

**Custom Code** - You can use the custom code section to specify custom html for the email.

You can specify custom variables using the [handlebars](https://handlebarsjs.com/guide/) syntax.

### SMS

Inside SMS, you can specify custom variables using [handlebars](https://handlebarsjs.com/guide/) syntax.

### In-app

In the notification center preview, you can type the content of the notification, select the content, and use `CMD` + `B` to make the selected text bold.

### Chat

You can specify custom variables using the [handlebars](https://handlebarsjs.com/guide/) syntax.

In addition to the integration, any subscriber needs to set credentials to have proper authorization on the channel.

The credentials can be saved through our `@novu/node` package.

# Trigger the workflow

After creating the workflow, Novu generates the trigger. Use the server SDK in your application in the appropriate place for the specific trigger.

```tsx theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<USER_IDENTIFIER>',
    email: 'email@email.com',
    firstName: 'John',
    lastName: 'Doe',
  },
  payload: {
    customVariables: 'Hello',
  },
});
```

The trigger function contains a parameters object as the second parameter. Let's explore its different options:

### `to` key

The `to` parameter contains the information about the subscriber of the notification. You can work with Novu in 2 modes:

### Pass the subscriber information in the trigger (Quickest)

You can pass the subscriber object containing the following keys as this parameter:

```tsx theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
    firstName,
    lastName,
    email,
    phone,
    avatar,
    locale,
  },
  payload: {},
});
```

The `subscriberId` is a custom identifier that identifies users within the Novu platform. We suggest using your internal DB identifier for this field.

When the trigger is called, Novu performs an upsert command, which either creates a subscriber with the specified payload, or updates the existing subscriber with the passed information.

**Note:** The API performs a PATCH command, updating only the fields passed to it. So to reset a specific field, you must explicitly pass `null` as the fields param.

### Pass only the `subscriberId` (Recommended)

```tsx theme={null}
{
  to: 'SUBSCRIBER_ID',
  payload: {}
}
```

In this approach, you only pass the `subscriberId` as part of the trigger, however, this approach requires you to identify the subscriber using the `identify` method from the `@novu/node`library.

### `payload` object

The `payload` object can pass any serializable JSON object to be used in the workflows.


# Go quickstart
Source: https://v0.x-docs.novu.co/quickstarts/go

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Go.

## Go Quickstart

Welcome to Go Quickstart guide for Novu. In this guide, you'll learn how to use Novu in a Go application. Novu is a powerful notification service that enables you to send multi-channel (SMS, Email, Chat, Push) notifications. Let's see how you can seamlessly integrate Novu into your Go project!

## Prerequisites

Before diving into the Quickstart, make sure you have the following:

* The [Go SDK](https://go.dev/doc/install) installed on your development machine.
* A Novu account. If you don't have one, sign up for free [here](https://web.novu.co?utm_campaign=docs-gs-quick-go)

## Install and Set Up Novu in your Go Project

First, you must install the Novu package in your Go project. From your terminal, you can install the Novu package in your project by running the following command:

```bash theme={null}
go get github.com/novuhq/go-novu

```

Once installed, you can import Novu into your project and initialize it using your Novu account credentials. This step establishes a connection between your app and the Novu notification service.

```go theme={null}
import (
 novu "github.com/novuhq/go-novu/lib"
)

novuClient := novu.NewAPIClient("<NOVU_API_KEY>", &novu.Config{})

```

Replace `<NOVU_API_KEY>` with your own API key that you got from the API Key section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-go).

<Note>
  🔑 Note: Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

## Configure retry

```go theme={null}
import (
 novu "github.com/novuhq/go-novu/lib"
)

novuClient := novu.NewAPIClient(apiKey, &novu.Config{RetryConfig: &novu.RetryConfigType{RetryMax: 3, WaitMin: 1 * time.Second, WaitMax: 5 * time.Second, InitialDelay: 0 * time.Second}})

```

| Options      | Detail                                                          | Default Value |
| ------------ | --------------------------------------------------------------- | ------------- |
| RetryMax     | Specifies total number of retries to perform in case of failure | 0             |
| WaitMin      | Specifies the minimum time to wait before retrying              | 0             |
| WaitMax      | Specifies the maximum time to wait before retrying              | 0             |
| InitialDelay | Specifies the initial delay before the first retry attempt      | 0             |

<Info>
  Above retry configuration is applied to all the sdk methods.
</Info>

## Set Up A Channel Provider

A channel provider is a service that lets you use one or more notification channels such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-go) currently supports four channels: Email, SMS, Chat, and Push. Each of these channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel** at a time. Connect anyone of your preferred providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Notification Workflow

A notification workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber.

The workflow includes the following:

* Notification workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be setup for the Chat channel.
</Note>

To create a notification workflow, please follow the following steps:

1. Click **Workflows** on the left sidebar of your Novu dashboard.

2. Click the **Create Workflow** button on the top right.

3. Select **blank workflow** from the dropdown.

4. The name of a new workflow is currently "Untitled." Rename it to a suitable title.

5. Select any channel you want to use in your app. For the sake of this guide, we'll be using the 'Email' channel.
   <Frame>
     <img />
   </Frame>

6. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

7. Click on the “Test” tab and send a test email to verify your notification workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. If you didn't, please check your 'spam' folder as sometimes test emails can end up there. Yaaay, you have successfully sent your first notification via the Novu dashboard!

Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display only one subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)


## Create a subscriber
func main() {
    ctx := context.Background()
    subscriberID := "<REPLACE_WITH_YOUR_SUBSCRIBER>"
    subscriber := novu.SubscriberPayload{
     LastName: "Skjæveland",
     Email:    "benedicte.skjaeveland@example.com",
     Avatar:   "https://randomuser.me/api/portraits/thumb/women/79.jpg",
     Data: map[string]interface{}{
      "location": map[string]interface{}{
       "city":     "Ballangen",
       "state":    "Aust-Agder",
       "country":  "Norway",
       "postcode": "7481",
      },
     },
    }

 resp, err := novuClient.SubscriberApi.Identify(ctx, subscriberID, subscriber)
 if err != nil {
  log.Fatal("Subscriber error: ", err.Error())
  return
 }

 fmt.Println(resp)
}

```

Run the code in your terminal like so:

```bash theme={null}
go run main.go # replace main.go with your file name

```

You should see a new subscriber (that you created above) on your Novu dashboard.

## Update A Subscriber

To update the Subscriber details you can call the put method from SubcriberApi. Here is an example:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Update subscriber details
func main() {
    ctx := context.Background()
    subscriberID := "<REPLACE_WITH_YOUR_SUBSCRIBER>"
    updateSubscriber := novu.SubscriberPayload{FirstName: "Susan"}
 updateResp, err := novuClient.SubscriberApi.Update(ctx, subscriberID, updateSubscriber)
 if err != nil {
  log.Fatal("Update subscriber error: ", err.Error())
  return
 }

 fmt.Println(updateResp)
}

```

<Note>
  Note: To send notifications to all your users, you'll need to make them subscribers in Novu, which you can do by programmatically adding them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Trigger A Notification
func main() {
    subscriberID := "<REPLACE_WITH_YOUR_SUBSCRIBER>"
 apiKey := "<REPLACE_WITH_YOUR_API_KEY>"
 eventId := "<REPLACE_WITH_YOUR_EVENT_ID>"

 ctx := context.Background()
 to := map[string]interface{}{
  "lastName":     "Nwosu",
  "firstName":    "John",
  "subscriberId": subscriberID,
  "email":        "johnnwosu@email.com",
 }
 payload := map[string]interface{}{
  "name": "Hello World",
  "organization": map[string]interface{}{
   "logo": "https://happycorp.com/logo.png",
  },
 }
 
 novuClient := novu.NewAPIClient(apiKey, &novu.Config{})
 triggerResp, err := novuClient.EventApi.Trigger(ctx, eventId, novu.ITriggerPayloadOptions{
  To:      to,
  Payload: payload,
 })
 if err != nil {
  log.Fatal("Novu error", err.Error())
  return
 }

 fmt.Println(triggerResp)
}

```

Before running the code, make sure you understand the following:

* The value of `eventId` should be the notification workflow's trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the notification template content.
* The value of `subscriberId` is the id of the subscriber on Novu.

Replace all items with their respective and accurate values.

Run the code to trigger a notification!

```bash theme={null}
go run main.go # replace main.go with your file name

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Create Topic
func main() {
    ctx := context.Background()
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
    topicName := "<REPLACE_WITH_YOUR_TOPIC_NAME>"
 createResp, err := novuClient.TopicsApi.Create(ctx, topicKey, topicName)
 if err != nil {
  log.Fatal("Create topic error: ", err.Error())
  return
 }

 fmt.Println(createResp)
}

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

## Add subscriber to Topic
func main() {
    ctx := context.Background()
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
    subscribers := []string{"<SUBSCRIBER_ID_1>", "<SUBSCRIBER_ID_2>"}
 addSubscribersResp, err := novuClient.TopicsApi.AddSubscribers(ctx, topicKey, subscribers)
 if err != nil {
  log.Fatal("Add subscriber to topic error: ", err.Error())
  return
 }

 fmt.Println(addSubscribersResp)
}

```

On the other hand, if you want to remove subscribers from a topic, do the following:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

## Remove subscriber from Topic
func main() {
    ctx := context.Background()
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
    subscribers := []string{"<SUBSCRIBER_ID_1>", "<SUBSCRIBER_ID_2>"}
 removeSubscribersResp, err := novuClient.TopicsApi.RemoveSubscribers(ctx, topicKey, subscribers)
 if err != nil {
  log.Fatal("Add subscriber to topic error: ", err.Error())
  return
 }

 fmt.Println(addSubscribersResp)
}

```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```go theme={null}
package main

import (
 "context"
 "fmt"
 "log"

 novu "github.com/novuhq/go-novu/lib"
)

// Trigger A Notification
func main() {
    topicKey := "<REPLACE_WITH_YOUR_TOPIC_KEY>"
 apiKey := "<REPLACE_WITH_YOUR_API_KEY>"
 eventId := "<REPLACE_WITH_YOUR_EVENT_ID>"
 ctx := context.Background()
 
 to := map[string]interface{}{
  "type":     "Topic",
  "topicKey":    topicKey
 }
 payload := map[string]interface{}{
  "name": "Hello World",
  "organization": map[string]interface{}{
   "logo": "https://happycorp.com/logo.png",
  },
 }
 
 novuClient := novu.NewAPIClient(apiKey, &novu.Config{})
    triggerResp, err := novuClient.EventApi.Trigger(ctx, eventId, novu.ITriggerPayloadOptions{
      To:      to,
      Payload: payload,
     })
 if err != nil {
  log.Fatal("Novu error", err.Error())
  return
 }

 fmt.Println(triggerResp)
}

```

## Next Steps

Great job! If you've reached this point, you should now have successfully created a subscriber, notification workflow, configured a channel provider and triggered a notification in your application.

To learn more about notifications and explore Novu's features and capabilities, check out:

* [Novu Digest Engine](https://docs.novu.co/platform/digest) - Learn how to aggregate multiple trigger events into a single message and deliver it to the subscriber.
* [Novu Go SDK](https://github.com/novuhq/go-novu) - Delve deeper into the SDK and explore a lot of features.
* [Novu Notification Center](/getting-started/introduction) - Learn how to integrate a rich, ready-to-use real-time UI notification center into your app.


# iFrame
Source: https://v0.x-docs.novu.co/quickstarts/iFrame

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with iFrame embed

## Requirements

To follow the steps in this quickstart, you’ll need:

* A Novu account. **[Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-iframe)** if you don’t have one yet.
* Basic knowledge of HTML and JavaScript.

You can also **[view the completed code](https://github.com/novuhq/iframe-quickstart)** of this quick start in a GitHub repo.

## Create a workflow

Before triggering a notification, we need to create a workflow. A workflow is like a blueprint that all the notifications are supposed to follow.

> The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

These are the steps to create a workflow:

1. Click **Workflow** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **“Untitled”**. Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.

<img />

Select the in-app channel.

1. Click on the recently added “In-App” channel and configure it according to your preferences. Once you’re done, click “Update” to save your configuration.

<img />

Configure the in-app node as per your needs.

I’ll briefly explain the function of each label in the image above:

* **1-Preview**: This shows you a glimpse of how each notification item will look in the Notification Center UI.
* **2-Avatar**: If turned on, each notification item will show the avatar of the subscriber.
* **3-Action**: With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds**: This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL**: This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter**: This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber’s online status to send them an email if they were online within the last hour. Read [more about filters](/workflows/notification-workflows).
* **7-Editor**: You can add text that you want to be displayed in each notification item. Additionally, you can specify custom variables using **`{{ }}`**. This means you can inject variables from your code into a notification item’s text via a payload.

In our case, we’ll use the custom variables functionality, as shown below:

<img />

We're gonna use custom variables here.

Feel free to add only text for now and rename the workflow to quickstart. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.
Rename the workflow to 'quickstart'.

<img />

Now, we’ll learn how to create subscribers on Novu - Recipients of Notifications!

## Create a subscriber

If you click “Subscriber” on the left sidebar of the **[Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-iframe)**, you’ll see the subscriber list. By default, there will only be one subscriber as you’re automatically added as a subscriber when you sign up for Novu:

<img />

<Note> One subscriber is automatically created when you sign up. If you don't see the default subscriber, follow [how to create subscriber](/subscribers/subscribers#create-a-subscriber) documentation to learn on how to create one </Note>

Now, let’s create a subscriber on Novu. After creating a subscriber, we’ll trigger a notification to this subscriber. Subscribers are identified by a unique **`subscriberId`**.

With Novu, you can create a subscriber using any of its SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin). The code to create a subscriber in Novu is:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.identify('123', {
  firstName: 'Sumit',
  lastName: 'Saurabh',
});
```

You can get your API key from the Novu dashboard. Replace **`<NOVU_API_KEY>`** with it. Now, if you’ll go to the Novu dashboard, you shall see the subscriber we created above with **`subscriberId`** of **`123`**.

You can also update information about an already existing subscriber using the **`subscriber.update`** method as shown below:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('123', {
  firstName: 'Saurabh', // new first name
  lastName: 'Sumit', // new last name
});
```

## Embed iFrame Notification Center in a your web app

1. Create a simple HTML file, you can call it `index.html`

2. Copy the following code snippet, it contains a basic html structure with some design elements to make things look more pretty

   <Note> Note that we are using fontAwesome library as a stylesheet dependency. </Note>

   ```html theme={null}
   <!DOCTYPE html>
   <html lang="en">

   <head>
       <meta charset="UTF-8">
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css">

       <title>iFrame Quickstart</title>
       <style>
           body {
               font-family: Arial, sans-serif;
               background-color: #f4f4f4;
               margin: 0;
               padding: 0;
               display: flex;
               justify-content: center;
               align-items: top;
               min-height: 100vh;
           }

           .container {
               text-align: center;
               padding: 20px;
               border-radius: 10px;
               background-color: #ffffff;
               box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.1);
           }

           h1 {
               color: #333333;
           }

           p {
               color: #666666;
               line-height: 1.6;
           }

           .fa {
               cursor: pointer;
           }

           .fa:hover {
               color: #0056b3;
           }
       </style>
   </head>

   <body>

       <div class="container">
           <h1>iFrame Notification Center Icon Bell</h1>
           <div id="notification-bell">
               <i class="fa fa-bell fa-2x"></i>
               <span id="unseen-badge"></span>
           </div>
           <p>Click on the notification bell to see the feed</p>
       </div>
       </div>

       <script>
       </script>
   </body>

   </html>
   ```

3. To activate the iFrame, you should include the following code as a script in your html app.

   ```jsx theme={null}
   <script>
     (function(n,o,t,i,f) {
       n[i] = {}; var m = ['init', 'on']; n[i]._c = [];m.forEach(me => n[i][me] = function() {n[i]._c.push([me, arguments])});
       var elt = o.createElement(f); elt.type = "text/javascript"; elt.async = true; elt.src = t;
       var before = o.getElementsByTagName(f)[0]; before.parentNode.insertBefore(elt, before);
     })(window, document, 'https://embed.novu.co/embed.umd.min.js', 'novu', 'script');

     novu.init(
       '<REPLACE_applicationIdentifier>',
       {
         unseenBadgeSelector: '#unseen-badge',
         bellSelector: '#notification-bell',
       },
       {
         subscriberId: '<REPLACE_WITH_subscriberId>',
       }
     );
   </script>
   ```

   You’ll notice two things used above - **`applicationIdentifier`** and **`subscriberID`**.

   An application identifier is a public key used to identify your application. You can get your own application identifier from the **[Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-iframe)**.

   And subscribers are users to which notifications will be sent. They are identified by a **`subscriberID`** which you can also find in the **[Novu subscribers dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-iframe)**.

4. Now open your html application, you should see something like this:

<img />

If you have replaced the `applicationIdentifier` and `subscriberID`, when you will click the bell, you will see the following:

<img />

To learn how to design and modify your iFrame component, feel free to visit the more in-depth [iFrame section](notification-center/client/iframe).

## Trigger a notification

We can trigger a notification by simply clicking on the `Get Snippet` button

<img />

Switch to `Run a Test` option

<img />

Change the `subscriberId` that we have created (`123`)

<img />

Click on `Run Trigger`

<img />

This will take the workflow we created above with the identifier `quickstart` and send a notification to the subscriber with `subscriberId` of `123`.

Now we will open our web application and see a red dot next to the bell icon, this indicate that we have an unseen notification in our feed.

When we will click on it, we will see our notification.

<img />

## Conclusion

Great job! If you’ve reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, triggered a notification and saw it in your web application using iFrame embed.

If you want to learn more about iFrame embed component, please visit [this section](/notification-center/client/iframe) of the documentation.


# Java quickstart
Source: https://v0.x-docs.novu.co/quickstarts/java

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Java.

## Java Quickstart

Learn how to integrate Novu into your Java project on the fly and send notifications across different channels (SMS, Email, Chat, Push).

In this Quickstart, you will learn how to:

* [Install and Set up the Novu Java SDK.](#install-and-set-up-the-novu-java-sdk-in-your-project)
* [Configure a Notification Channel Provider.](#set-up-a-channel-provider)
* [Set up a Notification Workflow.](#create-a-notification-workflow)
* [Create a Subscriber and update a Subscriber's information.](#create-a-subscriber-and-update-a-subscribers-information)
* [Send your first Notification to a Subscriber.](#trigger-a-notification)
* [Send Notifications via Topics.](#topics)

Let's get started! :muscle:

## Requirements

To be able to use this Quickstart, you would need to have the following:

* A Novu account, if you don't have one yet, [sign up](https://web.novu.co?utm_campaign=docs-gs-quick-java) for free.
* A working Java development environment with JDK 17 and Springboot Framework of 3.1.2+.

The completed code for this quick start is available on GitHub. Check it out [here](https://github.com/novuhq/novu-java-quickstart).

## Install and Set up the Novu Java SDK in your project

First, you need to import the library into your application.
If you use Maven, add the dependency to the `pom.xml` file;

```xml theme={null}
<dependency>
  <groupId>co.novu</groupId>
  <artifactId>novu-java</artifactId>
  <version>{use-latest-version}</version>
</dependency>
```

The latest version can be found [on GitHub.](https://github.com/novuhq/novu-java#installation)

If you use Gradle, add the dependency to the `build.gradle` file;

```groovy theme={null}
dependencies {
  implementation 'co.novu:novu-java:{use-latest-version}'
}
```

Sync your project, and you should have the artifacts downloaded.

To use the SDK, you need to have your API key handy, it can be gotten from [settings page](https://web.novu.co/settings?utm_campaign=docs-quick-java) of the web dashboard.

To initialize the library, you can create an instance of `Novu.java` class using any of the following constructors:

```java theme={null}
//Using the API Key only
String apiKey = "INSERT_API_KEY_HERE";
  Novu novu = new Novu(apiKey);
```

```java theme={null}
//Using the API Key plus an instance of NovuConfig
String apiKey = "INSERT_API_KEY_HERE";
  NovuConfig novuConfig = new NovuConfig(apiKey);
  Novu novu = new Novu(novuConfig);
```

Once that is done successfully, head over to the [web dashboard](https://web.novu.co?utm_campaign=docs-quick-java) for the next steps.

## Set up a Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification, etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-java) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favorite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Notification Workflow

A notification workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Notification workflow name and Identifier.
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a notification workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.

<Frame>
  <img />
</Frame>

3. The name of a new notification workflow is currently **Untitled**, rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select **Email** as the channel you want to add, by dragging it from the right sidebar.

<Frame>
  <img />
</Frame>

5. Click on the **Email** in the workflow and edit it as per this image. Don't forget to add the fields in the editor which is supposed to be updated with dynamic values that will be sent when calling the API.
   <Frame>
     <img />
   </Frame>

6. Also, add the variables in the **Variables** section in the test tab and try testing it by sending the email to your email address using the **Send Test Email** button at the bottom right.
   <Frame>
     <img />
   </Frame>

You should get an email within seconds! :ok\_hand:

Great, you have successfully sent your first notification via the Novu dashboard! Now, let's take a step further to trigger notifications via code.

## Create and Update a Subscriber's Information

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);

    SubscriberRequest subscriberRequest = new SubscriberRequest();
        subscriberRequest.setEmail("email");
        subscriberRequest.setFirstName("fName");
        subscriberRequest.setLastName("lName");
        subscriberRequest.setPhone("phone");
        subscriberRequest.setAvatar("avatar");
        subscriberRequest.setSubscriberId("subscriberId");
            try {
                return novu.createSubscriber(subscriberRequest);
            }catch (Exception e){
                log.error("Error Creating Subscriber", e);
            }

            return null;
```

When you run this code snippet, you should see the subscriber on your Novu dashboard.

Now, let's assume you want to modify the email address of the subscriber you just created, you can do that with the following code:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);

    UpdateSubscriberRequest updateSubscriberRequest = new UpdateSubscriberRequest();
        updateSubscriberRequest.setEmail("updatedEmail");
        updateSubscriberRequest.setFirstName("fName");
        updateSubscriberRequest.setLastName("lName");
        updateSubscriberRequest.setPhone("phone");
        updateSubscriberRequest.setAvatar("avatar");

        String subscriberId = "subscriberId";

        try {
            return novu.updateSubscriber(updateSubscriberRequest, subscriberId);
        }catch (Exception e){
            log.error("Error updating Subscriber", e);
        }

        return null;
```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an Object or a Map with the info you want to attach to the subscriber.

<Note>
  To create all of your subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger a Notification

Copy and paste the following code into your app to trigger a notification to a Subscriber:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);

    SubscriberRequest subscriberRequest = new SubscriberRequest();
            subscriberRequest.setSubscriberId("subscriberId");
            subscriberRequest.setEmail("email;");
            subscriberRequest.setFirstName("fName");
            subscriberRequest.setLastName("lName");

    TriggerEventRequest triggerEventRequest = new TriggerEventRequest();
            triggerEventRequest.setName("name");
            triggerEventRequest.setTo(subscriberRequest);
            triggerEventRequest.setPayload(Collections.singletonMap("customVariables", "Hello"));


    try {
        return novu.triggerEvent(triggerEventRequest);
    }catch (Exception e){
        log.error("Error triggering event", e);
    }

            return null;
```

Before running the code, make sure you understand the following:

* The value of `payload` is an array of the data that you want to be dynamically injected into the notification workflow content.
* The value of `subscriberId` is the ID of the subscriber on Novu. Replace `12345` with your subscriber ID.

Run the code to trigger a notification!

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops. A topic is identified by a custom key that is provided by the user, and this key will be the identifier used in the Topics API.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also caters for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```java theme={null}
String apiKey = "API_KEY";
Novu novu = new Novu(apiKey);

TopicRequest createTopicRequest = new TopicRequest();
    createTopicRequest.setKey("key");
    createTopicRequest.setName("name");
        try {
            return novu.createTopic(createTopicRequest);
        }catch (Exception e){
            log.error("Error creating Topic", e);
        }

        return null;
```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add Subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```java theme={null}
String apiKey = "API_KEY";
Novu novu = new Novu(apiKey);

        String topicKey = "key";
        SubscriberAdditionRequest requestBody = new SubscriberAdditionRequest();
        requestBody.setSubscribers(Collections.singletonList("aSubscriberId"));

        try {
            return novu.addSubscriberToTopic(requestBody,topicKey);
        }catch (Exception e){
            log.error("Error Adding Subscriber To Topic", e);
        }

        return null;
```

On the other hand, if you want to remove subscribers from a topic, do the following:

```java theme={null}
String apiKey = "API_KEY";
Novu novu = new Novu(apiKey);


        String topicKey = "key";
        SubscriberAdditionRequest requestBody = new SubscriberAdditionRequest();
        requestBody.setSubscribers(Collections.singletonList("aSubscriberId"));

        try {
            return novu.removeSubscriberFromTopic(requestBody, topicKey);
        }catch (Exception e){
            log.error("Error Removing Subscriber From Topic", e);
        }

        return null;
```

## Send a Notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```java theme={null}
String apiKey = "API_KEY";
    Novu novu = new Novu(apiKey);


    Topic topic = new Topic();
        topic.setType("Topic");
        topic.setTopicKey("topicKey");

    TriggerEventRequest triggerEventRequest = new TriggerEventRequest();
            triggerEventRequest.setName("name");
            triggerEventRequest.setTo(topic);
            triggerEventRequest.setPayload(Collections.singletonMap("customVariables", "Hello"));


    try {
        return novu.triggerEvent(triggerEventRequest);
    }catch (Exception e){
        log.error("Error sending notification to topic", e);
    }

            return null;
```

## Next Steps

Great job! :clap: If you've reached this point, you should have successfully created a subscriber, notification workflow, configured a channel provider, triggered a single notification, created a topic, added a subscriber to a topic in your application.

To learn more about notifications and explore Novu's features and capabilities, check out:

* [Novu Java SDK](https://github.com/novuhq/novu-java) - Dive deeper into the SDK and explore a lot of features.
* [Novu Digest Engine](/guides/add-digest-to-inapp-notifications) - Learn how to aggregate multiple trigger events into a single message and deliver it to the subscriber.
* [Novu Notification Center](/getting-started/introduction) - Learn how to integrate a rich, ready-to-use real-time UI notification center into your app.


# Kotlin quickstart
Source: https://v0.x-docs.novu.co/quickstarts/kotlin

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Kotlin.

Learn how to integrate Novu into your Kotlin project on the fly and send notifications across different channels (SMS, Email, Chat, Push).

Let's get started! 💪

## Requirements

To be able to use this Quickstart, you would need to have the following:

* A Novu account, if you don't have one yet, [sign up](https://web.novu.co/?utm_campaign=docs-gs-quick-kotlin) for free.
* A working Kotlin project running version 1.6.0+ and Kotlin compiler 1.8.0+.

The completed code for this quick start is available on GitHub. Check it out [here](https://github.com/novuhq/novu-kotlin-quickstart).

## Install and Set up the Novu Kotlin SDK in your project

First, you need to import the library into your application.

If you use Maven, add the dependency to the `pom.xml` file;

```xml theme={null}
<dependency>
  <groupId>co.novu</groupId>
  <artifactId>novu-kotlin</artifactId>
  <version>{use-latest-version}</version>
</dependency>
```

The latest version can be found [on GitHub.](https://github.com/novuhq/novu-kotlin#installation)

If you use Gradle, add the dependency to the `build.gradle` file;

```groovy theme={null}
implementation 'co.novu:novu-kotlin:{use-latest-version}' //Groovy

implementation ("co.novu:novu-kotlin:{use-latest-version}") //Kotlin
```

Sync your project, and you should have the artifacts downloaded.

To use the SDK, you need to have your API key handy, it can be gotten from the [settings page](https://web.novu.co/settings?utm_campaign=docs-quick-kotlin) of the web portal.

To initialize the library, you can create an instance of `Novu.kt` class using any of the following constructors:

```kotlin theme={null}
//Using the API Key only
val novu = Novu(apiKey = "API_KEY")

```

```kotlin theme={null}
//Using the API Key plus an instance of NovuConfig
val novuConfig = NovuConfig(backendUrl = "URL")
val novu = Novu(apiKey = "API_KEY", config = novuConfig)

```

Once that is done successfully, head over to the [web portal](https://web.novu.co/?utm_campaign=docs-quick-kotlin) for the next steps.

## Set up a Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification, etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-kotlin) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favourite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier.
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.

<Frame>
  <img />
</Frame>

3. The name of the new workflow is currently Untitled, rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select Email as the channel you want to add, by dragging it from the right sidebar.

<Frame>
  <img />
</Frame>

5. Click on the Email in the workflow and edit it as per this image. Don’t forget to add the fields in the editor which is supposed to be updated with dynamic values that will be sent when calling the API.

<Frame>
  <img />
</Frame>

6. Also, add the variables in the Variables section in the test tab and try testing it by sending the email to your email address using the Send Test Email button at the bottom right.

<Frame>
  <img />
</Frame>

You should get an email within seconds! 👌

Great, you have successfully sent your first notification via the Novu dashboard! Now, let’s take a step further to trigger notifications via code.

## Create a Subscriber and Update a Subscriber's information

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```kotlin theme={null}
suspend fun createSubscriber(): ResponseWrapper<SubscriberResponse>? {
        val novu = Novu(apiKey = "API_KEY")
        val subscriberRequest = SubscriberRequest(
            email = "email@sample.com",
            firstName = "John",//optional
            lastName = "Doe",//optional
            phone = "123456789",//optional
            avatar = "sample-avatar",//optional
            subscriberId = "12345"//optional
        )
        return CoroutineScope(Dispatchers.IO).async {
            novu.createSubscriber(subscriberRequest)
        }.await()
    }

```

When you run this code snippet, you should see the subscriber on your Novu dashboard. 👤

Now, let's assume you want to modify the email address of the Subscriber you just created, you can do that with the following code:

```kotlin theme={null}
suspend fun updateSubscriber(): ResponseWrapper<SubscriberResponse>? {
        val novu = Novu(apiKey = "API_KEY")
        val subscriberRequest = UpdateSubscriberRequest(
            email = "validemail@sample.com",
            firstName = "John",//optional
            lastName = "Doe",//optional
            phone = "123456789",//optional
            avatar = "sample-avatar"//optional
        )
        val subscriberId = "12345"
        return CoroutineScope(Dispatchers.IO).async {
            novu.updateSubscriber(subscriberId, subscriberRequest)
        }.await()
    }

```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an Object or a Map with the info you want to attach to the subscriber.

<Note>
  To create all of your subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger a Notification

Copy and paste the following code into your app to trigger a notification to a Subscriber:

```kotlin theme={null}
suspend fun triggerNotification(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val triggerEventRequest = TriggerEventRequest(
            name = "test",
            to = SubscriberRequest(
                subscriberId = "12345",
                email = "email@email.com",
                firstName = "John",
                lastName = "Doe"
            ),
            payload = mapOf("customVariables" to "Hello")
        )

        return CoroutineScope(Dispatchers.IO).async {
            novu.trigger(triggerEventRequest)
        }.await()
    }

```

Before running the code, make sure you understand the following:

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the ID of the subscriber on Novu. Replace `12345` with your subscriber ID.

Run the code to trigger a notification! 📧

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops. A topic is identified by a custom key that is provided by the user, and this key will be the identifier used in the Topics API.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also caters for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```kotlin theme={null}
suspend fun createTopic(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val createTopicRequest = CreateTopicRequest(
            key = "key",
            name = "name"
        )
        return CoroutineScope(Dispatchers.IO).async {
            novu.createTopic(createTopicRequest)
        }.await()
    }

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```kotlin theme={null}
suspend fun addSubscriberToTopic(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val topicKey = "key"
        val requestBody = SubscriberList(listOf("name"))
        return CoroutineScope(Dispatchers.IO).async {
            novu.addSubscribers(topicKey, requestBody)
        }.await()
    }

```

On the other hand, if you want to remove subscribers from a topic, do the following:

```kotlin theme={null}
suspend fun removeSubscriberFromTopic(): Any? {
        val novu = Novu(apiKey = "API_KEY")
        val topicKey = "key"
        val requestBody = SubscriberList(listOf("name"))
        return CoroutineScope(Dispatchers.IO).async {
            novu.removeSubscriber(topicKey, requestBody)
        }.await()
    }

```

## Sending a Notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```kotlin theme={null}
suspend fun triggerNotificationToTopic(): Any? {
        val novu = Novu(apiKey = "NOVU_API_KEY")
        val triggerEventRequest = TriggerEventRequest(
                name = "test",
                to = listOf(
                        Topic(
                                type = "Topic",
                                topicKey = "posts:comment:12345"
                        )
                ),
                payload = mapOf("customVariables" to "Hello")
        )

        return CoroutineScope(Dispatchers.IO).async {
            novu.trigger(triggerEventRequest)
        }.await()
    }
```

## Conclusion

Great job! 👏
If you've reached this point, you should have successfully created a subscriber, workflow, configured a channel provider, triggered a single notification, created a topic, and added a subscriber to a topic in your application.


# NextJS
Source: https://v0.x-docs.novu.co/quickstarts/nextjs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with NextJS.

This quick start guide is written to help you integrate Novu into your NextJS app in no time. Novu is an open-source notifications infrastructure that you can use in your app to deliver rich notifications across channels like sms, email, in-app, push, chat, etc. In this guide, you’ll learn how to integrate email notifications into your NextJS app.

You can find the code for this app [here](https://github.com/novuhq/nextjs-quickstart/)

## Prerequisites

* Node.js installed on your development machine (to create a NextJS app).
* A Novu account. If you don't have one, sign up for free [here](https://web.novu.co/workflows?utm_campaign=docs-quick-nextjs).

## Create a NextJS app to get started

The first step here would be to create a NextJS app. We will play with Novu in this app later. To get started, open your terminal and create a NextJS app using the following command:

```bash theme={null}
npx create-next-app@latest

```

This will create a NextJS app and now we can add Novu to our project. Open the app using a code editor of your choice. The benefit of using NextJS is that it provides native support for routing, making it effortless to handle navigation and create dynamic pages in your application.

Next.js uses a file-based routing system, where each page in your application is represented by a corresponding file in the `pages` directory.

By creating a new file in the `pages` directory, such as `about.js`, we automatically create a route `/about` in our application. Next.js handles the routing logic behind the scenes, ensuring that when a user accesses `/about`, the corresponding page component is rendered.

In our app, we’ll create a route that will send an email notification to a specified email id. To do this, we need two things:

* Install Novu and connect it to our app
* Create the route and define a function in that route

## Installing Novu and connecting it to the app

To install Novu, simply open your terminal and issue the following command:

```bash theme={null}
npm install @novu/node

```

After installing it, we need to connect our app with our Novu account using the Novu API key. Simply log onto the [Novu web dashboard](https://web.novu.co?utm_campaign=docs-quick-nextjs/) and from the settings there, obtain your API key. We’ll use it to connect our app to our Novu account.

<Frame>
  <img />
</Frame>

Now, we need to connect it to our app. To do so, the first step is to import Novu into our app. Importing Novu will give us the ability to interact with the Novu API. To import Novu into our app, use the following code in a separate file in our app:

```jsx theme={null}
import { Novu } from '@novu/node';

// replace <NOVU_API_KEY> with your actual API key
const novu = new Novu(<NOVU_API_KEY>);
```

Novu lets us send notifications across different channels like email, in-app, chat, SMS, etc, and for each channel, one can use a plethora of providers. You just need to set up a provider for the channel you want to use in Novu:

| Channel | Providers                                                           |   |
| ------- | ------------------------------------------------------------------- | - |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |   |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |   |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |   |
| Push    | FCM, APNS, Expo                                                     |   |

You can see all this in our [integrations store](https://web.novu.co/integrations?utm_campaign=docs-quick-nextjs) and set it up there.

For each channel, there can be only one provider active at a time. Although the exact setup process varies from provider to provider, the general flow is signing up for a provider, getting an API key from its portal, and plugging it into the Novu web portal.

Once having integrated a provider, we need a workflow to send notifications. One can have dynamic data in this workflow if they so choose.

In our case, we’ll have dynamic data and whatever we send as a description will be sent as an email notification. Following are the steps to create a workflow.

## Creating a workflow

1. Click "Workflows” on the left sidebar of your Novu dashboard.
2. Click the “Create Workflow” button on the top right.

<Frame>
  <img />
</Frame>

3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select "Email" as the channel you want to add, by dragging it from the right sidebar:

<Frame>
  <img />
</Frame>

5. Click on the ‘Email’ in the workflow and edit it as per this image. Don’t forget to add the fields in the editor which is supposed to be updated with dynamic values that we’ll send when calling the API.

<Frame>
  <img />
</Frame>

6. Also, add the variables in the ‘variables’ section in the test tab and try testing it by sending the email to your email id using the ‘send test email’ button on the bottom right.

<Frame>
  <img />
</Frame>

Now, we’ve successfully sent the test email and just need to do this from our app.

## Subscribers

In Novu, entities that are supposed to receive notifications are called subscribers. You can see all the subscribers in the ‘subscribers’ tab in the left menu on the Novu web portal. There would be one subscriber by default, which is you. This was created when you signed up for Novu.

In real-world scenarios, the `subscriber id` would be a unique id generated automatically by the database. So for our demo purpose, we’re using a simple subscriber id of ‘1234567890’ in our app.

We’ll first create a subscriber using the following code:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu(<NOVU_API_KEY>);

export async function sendEmail(email, description) {
    await novu.subscribers.identify('1234567890', {
        email: email,
        firstName: "Subscriber",
    });
}

```

Here, we’re creating a subscriber with the subscriber id of `1234567890` and now we’ll send a notification to the subscriber with this very subscriber id by triggering an email notification like follows:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu(<NOVU_API_KEY>);

export async function sendEmail(email, description) {
    await novu.subscribers.identify('1234567890', {
        email: email,
        firstName: "Subscriber",
    });
    await novu.trigger('email-quickstart', {
        to: {
            subscriberId: '1234567890',
            email: email
        },
        payload: {
            email: email,
            description: description
        }
    });
}

```

We’ve exported this function so that we can use this in the route that we’ll now create.

## Create the route and define a function in that route

Now, create a `pages` directory in the root of the project and create a file in it. Give it a name and remember that it will automatically become a route.

In our case, we’re creating a directory called `api` in our pages directory, and inside `api` we’re creating a file called `sub.js`. In this case, our path will be: `http://localhost:3000/api/sub`

In this file, we simply need to define a function that will handle a POST request to our API. It’ll extract the ‘description’ and ‘email’ variables from the ‘request’ body that will be generated every time we make a POST request and call the function to send an email notification with those plugged in.

We’d used these variables in the workflow we had created in the Novu dashboard and also specified the same in the trigger function above.

The function in our route is quite simple and looks like this:

```jsx theme={null}
import { sendEmail } from '@/app/utils/novu';

export default async function subscribe(req, res) {
  try {
    if (req.method === 'POST') {
      const { email, description } = req.body;
      await sendEmail(email, description);
      await res.status(200).json({ message: 'email working' });
    }
  } catch (error) {
    console.log(error);
    res.status(405).json({ message: 'not working' });
  }
}

```

We can now start our local server and test our backend app on Postman. To start the local server, use the following command:

```bash theme={null}
npm run dev

```

Now, open Postman and send a POST request to the route you created earlier. The exact route depends on the file structure you have followed in the pages directory, but in our case, it is - `http://localhost:3000/api/sub`

Also, make sure that in the body, you’re passing the two variables we’re extracting above, namely - email and description, as follows:

<Frame>
  <img />
</Frame>

> In place of [youremail@gmail.com](mailto:youremail@gmail.com), use your actual email and once you send it, you should see the ‘message: email working’ on the bottom as in the image above.

This means that the email notification was sent successfully. Now go to your inbox and you should see an email notification like the following:

<Frame>
  <img />
</Frame>

## Topics

Novu simplifies the process of triggering notifications to multiple subscribers with an API called "Topics". By utilizing the Topics API, you can effortlessly manage bulk notifications easily.

Each topic is uniquely identified by a custom key specified by the user, serving as the primary identifier for interacting with the Topics API.

This intuitive approach streamlines notifications management, empowering users to focus on delivering targeted messages to their subscribers without the hassle of intricate implementation details.

> Make sure that you use a unique key for a Topic. Keys once used, can’t be changed later!

You have the flexibility to assign a descriptive name to a topic. Unlike the topic key, this name does not require uniqueness and can be modified using the provided API.

A topic can have multiple subscribers associated with it. These subscribers will receive notifications whenever a notification is dispatched to the respective topic.

## Create a topic

You can create a topic using two entities - `key` and `name`. Keys are unique identifiers for topics and a name is just something you assign to a topic for convenience.

```jsx theme={null}
import { Novu } from '@novu/node';

export default async function createTopic(req, res) {
  try {
    const novu = new Novu("<NOVU_API_KEY>");
    if (req.method === 'POST') {
      const { key, name } = req.body;
      const result = await novu.topics.create({ key, name });
      res.status(201).json(result.data);
    }
  } catch (error) {
    console.log(error);
    res.status(500).json({ message: error.message });
  }
}

```

This is a simple function that calls the **`create`** method on the **`topics`** property of the \*\*`novu`\*\*instance. This method creates a new topic in the Novu system using the provided **`key`** and **`name`** values.

If you test this on your local machine, you should get something like this:

<Frame>
  <img />
</Frame>

> Note how the return object contains the key I sent from my request body. That signals successful creation!

## Add subscriber to a Topic

The code for adding a subscriber to a previously created topic is as follows:

<Note>
  You can only add those subscribers to a topic that you've already created. You can see all the subscribers in the [Novu web dashboard](https://web.novu.co/subscribers)?utm\_campaign=docs-quick-nextjs
</Note>

```jsx theme={null}
import { Novu } from '@novu/node';

export default async function addSub(req, res) {
  try {
    const novu = new Novu("<NOVU_API_KEY>");
    if (req.method === 'POST') {
      // Get the subscriber ID from the request body
      const subscriberId = req.body.subscriberId;
      // Get the topic key from the request body
      const topicKey = req.body.topicKey;
      // Call Novu SDK to add the subscriber to the topic
      const result = await novu.topics.addSubscribers(topicKey, {
        subscribers: [subscriberId],
      });
      // Return the result as JSON response
      res.status(200).json(result.data);
    }
  } catch (error) {
    console.log(error);
    res.status(500).json({ message: error.message });
  }
}

```

If you see the code above closely, you’ll see that we first establish a connection to Novu using the Novu API key.

Then we extract `subscriberID` and topicKey from the request body and call the **`addSubscribers`** method on the **`topics`** property of the **`novu`** instance, passing the topic key and an object with an array of subscribers.

This adds the subscriber with the `subscriberID` we’d passed to the array of subscribers, which in the above case contains just one subscriber.

If you check this on Postman, the returned array will contain the `subscriberID` that we had passed in the request body, signalling that it was added to the topic successfully.

If, on the other hand, you find the passed `subscriberId` in the `notFound` array inside the `failed` object, it means the subscriber wasn't added to the topic.

You can read more about it [here](https://docs.novu.co/platform/topics/#subscribers-management-in-a-topic).

The image below shows the case where the subscriber has been added successfully:

<Frame>
  <img />
</Frame>

After creating a topic and adding subscribers to the topic, we’ll now proceed to send a notification to all subscribers (we only have one subscriber in our topic though) of a topic. This is what Topics are used for - sending bulk notifications.

## Sending notifications to a topic

Sending notifications to a topic is not a complex task. You need to extract the topic key to which you want to send notifications and trigger Novu’s method on that topic key with the message in the payload:

```jsx theme={null}
import { Novu } from '@novu/node';

export default async function sendNotifToSub(req, res) {
  try {
    const novu = new Novu("<NOVU_API_KEY>");
    if (req.method === 'POST') {
      // Get the topic key from the request body
      const topicKey = req.body.topicKey;
      const email = req.body.email;
      const description = req.body.description;

      // Call Novu SDK to trigger a notification to the topic subscribers
      const result = await novu.trigger('email-quickstart', {
        to: [{ type: 'Topic', topicKey: topicKey }],
        payload: {
          email: email,
          description: description,
        },
      });
      // Return the result as JSON response
      res.json(result.data);
    }
  } catch (error) {
    console.log(error);
    res.status(500).json({ message: error.message });
  }
}

```

Testing this on Postman should give you something like this:

<Frame>
  <img />
</Frame>

If you see this, then it means the notification was sent successfully, as can be seen in my inbox down below:

<Frame>
  <img />
</Frame>

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, and workflow, configured a channel provider, triggered a single notification, and sent an email notification.


# NodeJS quickstart
Source: https://v0.x-docs.novu.co/quickstarts/nodejs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Node.js.

Welcome to the Node.js Quickstart guide for Novu, a powerful notification service that enables you to send multi-channel (SMS, Email, Chat, Push) notifications from your Node.js applications. In this Quickstart, you'll learn how to seamlessly integrate Novu into your app and perform various essential tasks. Let's get started!

## Prerequisites

Before diving into the Quickstart, make sure you have the following:

* Node.js installed on your development machine.
* A Novu account. If you don't have one, sign up for free at [the web dashboard](https://web.novu.co/?utm_campaign=docs-quick-nodejs)

You can also [view the completed code](https://github.com/novuhq/nodejs-sdk-quickstart) of this quick start in a GitHub repo.

## Install and Set Up Novu in your Node.js App

First, you must install the Novu package in your Node.js application. Open your terminal and run the following command:

```bash theme={null}
npm install @novu/node

```

Once installed, you can import Novu into your app and initialize it using your Novu account credentials. This step establishes a connection between your app and the Novu notification service.

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');
```

Replace the `<NOVU_API_KEY>` value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-nodejs).

🔑 Note: Please do not hardcode your credentials in a file in production. Use environment variables instead.

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-nodejs) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favorite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Workflow

A workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Note: Proper authorization needs to be set for the Chat channel for subscribers.

Please proceed to create a workflow.

1. Click “Workflows” on the left sidebar of your Novu dashboard.
2. Click the “Create Workflow” button on the top right.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select "Email" as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

6. Click on the “Test” tab and send a test email to verify your workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. Yaaay, you have successfully sent your first notification via the Novu dashboard! Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click “Subscribers” on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```jsx theme={null}
// Create a subscriber
const subscriberId = '7789'; // Replace this with a unique user ID that matches your database.
await novu.subscribers.identify(subscriberId, {
  email: 'abc@gmail.com', // optional
  firstName: 'John', // optional
  lastName: 'Doe', // optional
  phone: '', // optional
  avatar: '', // optional
  locale: '', // optional
  data: { customKey1: 'customVal1', customKey2: 'customVal2' }, // optional
});
```

Run the code in your terminal like so:

```bash theme={null}
node index.js

```

You should see the subscriber on your Novu dashboard.

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `updateSubscriber` method like so:

```jsx theme={null}
// Update subscriber detail
await novu.subscribers.update('7789', {
  // new email
  email: 'validemail@gmail.com', // optional
  // new phone
  phone: '+19874567832', // optional
});
```

Other valid fields that can be updated are `phone`, `avatar`, and `data` . The `data` field can accept an array of metadata that you want to attach to the subscriber.

Note: To make all of your app users subscribers, you need to programmatically add them to Novu.

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```jsx theme={null}
const notificationWorkflowId = 'first-email';

novu.trigger(notificationWorkflowId, {
  to: {
    subscriberId: '7789',
  },
  payload: {},
});
```

Before running the code, make sure you understand the following:

* The value of `notificationWorkflowId` should be the workflow's trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriber ID.

Run the code to trigger a notification!

```bash theme={null}
node index.js

```

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called "Topics" and allows users to manage their bulk notifications without having to implement complex loops. A topic is identified by a custom key that is provided by the user, and this key will be the identifier used in the Topics API.

⚠️ DANGER: The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.

Users can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed using the API.

A topic can have different subscribers, who will receive a notification whenever a notification is sent to the topic.

## Create a topic

Copy and paste the following code into your app to create a topic:

```jsx theme={null}
const result = await novu.topics.create({
  key: 'unique-topic-identifier',
  name: 'descriptive-topic-name',
});
```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add Subscribers To A Topic

Copy and paste the following code into your app to add subscribers to a topic.

```jsx theme={null}
const topicKey = '<YOUR TOPIC KEY>';

const response = await novu.topics.addSubscribers(topicKey, {
  subscribers: ['subscriber-id-1', 'subscriber-id-2', ...],
});
```

* To add multiple subscribers to a topic, simply separate their names with commas and add them to the array as part of the `subscribers` value.

## Send Notification To A Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, use Novu's API as follows:

```jsx theme={null}
const topicKey = '<TOPIC_KEY>';
const notificationTemplateId = '<WORKFLOW_TRIGGER_IDENTIFIER>';

await novu.trigger(notificationTemplateId, {
  to: [{ type: 'Topic', topicKey: topicKey }],
  payload: {},
});
```

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider, triggered a single notification, created a topic, added a subscriber to a topic and even triggered a notification to a topic in your application.


# Quickstarts
Source: https://v0.x-docs.novu.co/quickstarts/overview

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with any language/framework of your choice.

<CardGroup>
  <Card title="Vue" icon="vuejs" href="/quickstarts/vue">
    Embed a real-time notification center component in your Vue application.
  </Card>

  <Card title="React" icon="react" href="/quickstarts/react">
    Embed a real-time notification center component in your React application.
  </Card>

  <Card title="Angular" icon="angular" href="/quickstarts/angular">
    Embed a real-time notification center component in your Angular application.
  </Card>

  <Card title="VanillaJS" icon="js" href="/quickstarts/vanillajs">
    Embed a real-time notification center component in your VanillaJS
    application.
  </Card>

  <Card
    title="RedwoodJS"
    icon={
  <svg
    xmlns="http://www.w3.org/2000/svg"
    width="25"
    height="23"
    viewBox="0 0 256 277"
  >
    <path
      fill="#FFF"
      d="M112.39 3.928C101.983 9.164 80.046 19.36 68.16 27.493c-11.885 8.134-10.407 15.711-15.61 20.948c-5.203 5.237-20.814 18.329-31.22 26.184c-10.407 7.855-7.806 28.803-10.407 36.658c-2.602 7.855-7.806 26.184-10.407 34.04c-2.602 7.855 5.203 18.329 10.407 28.802c5.203 10.474 18.211 39.277 23.415 49.75c5.203 10.474 20.813 5.237 33.822 15.71c13.009 10.475 31.22 23.568 44.229 31.423c13.008 7.855 18.212 7.855 31.22 0c13.009-7.855 31.22-20.948 44.23-31.422c13.008-10.474 28.618-5.237 33.822-15.71c5.203-10.474 18.211-39.277 23.415-49.75c5.203-10.474 13.008-20.948 10.406-28.803c-2.602-7.856-7.804-26.185-10.406-34.04c-2.602-7.855 0-28.803-10.407-36.658s-22.487-17.857-31.22-26.184c-8.734-8.327-5.204-13.092-15.61-20.948c-10.407-7.855-33.823-18.329-44.23-23.565c-10.406-5.237-20.813-5.237-31.22 0Z"
    />
    <path
      fill="#BF4722"
      d="m75.644 49.319l48.694 33.238a6.886 6.886 0 0 0 3.7 1.155a6.665 6.665 0 0 0 3.7-1.155l48.73-33.35a6.65 6.65 0 0 0 2.748-5.947a6.633 6.633 0 0 0-3.672-5.418L130.85 13.733a6.692 6.692 0 0 0-5.846 0l-48.546 24.11a6.633 6.633 0 0 0-3.707 5.5a6.649 6.649 0 0 0 2.893 5.976Zm68.933 43.671a6.721 6.721 0 0 0 2.886 5.515l39.037 26.68a6.55 6.55 0 0 0 8.103-.522l32.746-29.288a6.654 6.654 0 0 0 2.213-5.156a6.648 6.648 0 0 0-2.509-5.017L195.787 60.2a6.623 6.623 0 0 0-7.844-.298l-40.48 27.686a6.72 6.72 0 0 0-2.886 5.403Zm-97.09 36.293a6.696 6.696 0 0 1 2.182 5.627a6.524 6.524 0 0 1-3.293 5.068l-23.31 13.973a6.586 6.586 0 0 1-7.5-.512a6.698 6.698 0 0 1-2.195-7.238l8.621-27.127a6.607 6.607 0 0 1 4.551-4.397a6.406 6.406 0 0 1 6.143 1.453l14.8 13.153Zm126.432 2.832l-42.144-28.84a6.622 6.622 0 0 0-7.4 0l-42.145 28.84a6.754 6.754 0 0 0-2.886 5.068a6.88 6.88 0 0 0 2.22 5.44l42.108 37.672a6.597 6.597 0 0 0 4.403 1.677a6.63 6.63 0 0 0 4.403-1.677l42.107-37.672a6.73 6.73 0 0 0 2.183-5.44a6.606 6.606 0 0 0-2.849-5.068Zm-112.41-7.452L28.802 95.375a6.804 6.804 0 0 1-2.22-5.254a6.574 6.574 0 0 1 2.478-5.03l31.266-25.152a6.696 6.696 0 0 1 7.882-.298l40.442 27.685a6.682 6.682 0 0 1 3.01 5.59a6.682 6.682 0 0 1-3.01 5.589l-39 26.68a6.624 6.624 0 0 1-8.14-.522Zm167.95 42.069l-33.302-19.935a6.55 6.55 0 0 0-7.77.745l-40.702 36.33a6.696 6.696 0 0 0-2.13 6.13a6.66 6.66 0 0 0 4.055 5.05l56.463 22.878a6.333 6.333 0 0 0 2.442.485c2.621.008 5-1.54 6.069-3.95l17.501-39.2c1.425-3.102.29-6.787-2.627-8.533Zm4.624-47.658l8.622 27.127h-.074a6.71 6.71 0 0 1-.975 5.958a6.61 6.61 0 0 1-5.353 2.724a6.478 6.478 0 0 1-3.367-.932l-23.348-13.973a6.489 6.489 0 0 1-3.182-5.068a6.62 6.62 0 0 1 2.183-5.627l14.8-13.19a6.59 6.59 0 0 1 6.143-1.454a6.72 6.72 0 0 1 4.551 4.435Zm-123.51 70.91a6.66 6.66 0 0 0-2.109-6.111l-40.701-36.331a6.55 6.55 0 0 0-7.77-.745L26.69 166.732c-2.883 1.754-4.024 5.392-2.664 8.496l17.539 39.2c1.453 3.268 5.21 4.798 8.51 3.465l56.427-22.88a6.659 6.659 0 0 0 4.07-5.03Zm19.98 11.178l45.29 18.333a6.665 6.665 0 0 1 3.997 5.44a6.614 6.614 0 0 1-2.813 6.223l-45.326 31.488a6.551 6.551 0 0 1-3.7 1.191a6.682 6.682 0 0 1-3.7-1.191l-45.29-31.488a6.651 6.651 0 0 1-2.849-6.222a6.775 6.775 0 0 1 4.144-5.44l45.29-18.334a6.69 6.69 0 0 1 4.958 0Z"
    />
  </svg>
}
    href="/quickstarts/redwoodjs"
  >
    Embed a real-time notification center component in your RedwoodJS
    application.
  </Card>

  <Card title="iFrame" icon="html5" href="/quickstarts/iFrame">
    Embed a real-time notification center component in your iFrame application.
  </Card>

  <Card title="Node.js" icon="node" href="/quickstarts/nodejs">
    Connect a Node.js application to Novu.
  </Card>

  <Card
    title="PHP"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#deviconPhp0)" d="M0 64c0 18.593 28.654 33.667 64 33.667c35.346 0 64-15.074 64-33.667c0-18.593-28.655-33.667-64-33.667C28.654 30.333 0 45.407 0 64Z"/><path fill="#777bb3" d="M64 95.167c33.965 0 61.5-13.955 61.5-31.167c0-17.214-27.535-31.167-61.5-31.167S2.5 46.786 2.5 64c0 17.212 27.535 31.167 61.5 31.167Z"/><path d="M34.772 67.864c2.793 0 4.877-.515 6.196-1.53c1.306-1.006 2.207-2.747 2.68-5.175c.44-2.27.272-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.464l-2.473 12.732zM20.173 83.547a.694.694 0 0 1-.68-.828l6.557-33.738a.695.695 0 0 1 .68-.561h14.134c4.442 0 7.748 1.206 9.827 3.585c2.088 2.39 2.734 5.734 1.917 9.935c-.333 1.711-.905 3.3-1.7 4.724a15.818 15.818 0 0 1-3.128 3.92c-1.531 1.432-3.264 2.472-5.147 3.083c-1.852.604-4.232.91-7.07.91h-5.724l-1.634 8.408a.695.695 0 0 1-.682.562z"/><path fill="#fff" d="M34.19 55.826h3.891c3.107 0 4.186.682 4.553 1.089c.607.674.723 2.097.331 4.112c-.439 2.257-1.253 3.858-2.42 4.756c-1.194.92-3.138 1.386-5.773 1.386h-2.786l2.205-11.342zm6.674-8.1H26.731a1.39 1.39 0 0 0-1.364 1.123L18.81 82.588a1.39 1.39 0 0 0 1.363 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.151c2.912 0 5.364-.318 7.287-.944c1.977-.642 3.796-1.731 5.406-3.237a16.522 16.522 0 0 0 3.259-4.087c.831-1.487 1.429-3.147 1.775-4.931c.86-4.423.161-7.964-2.076-10.524c-2.216-2.537-5.698-3.823-10.349-3.823zM30.301 68.557h4.471c2.963 0 5.17-.557 6.62-1.675c1.451-1.116 2.428-2.98 2.938-5.591c.485-2.508.264-4.277-.665-5.308c-.931-1.03-2.791-1.546-5.584-1.546h-5.036l-2.743 14.12m10.563-19.445c4.252 0 7.353 1.117 9.303 3.348c1.95 2.232 2.536 5.347 1.76 9.346c-.322 1.648-.863 3.154-1.625 4.518c-.764 1.366-1.76 2.614-2.991 3.747c-1.468 1.373-3.097 2.352-4.892 2.935c-1.794.584-4.08.875-6.857.875h-6.296l-1.743 8.97h-7.35l6.558-33.739h14.133"/><path d="M69.459 74.577a.694.694 0 0 1-.682-.827l2.9-14.928c.277-1.42.209-2.438-.19-2.87c-.245-.263-.979-.704-3.15-.704h-5.256l-3.646 18.768a.695.695 0 0 1-.683.56h-7.29a.695.695 0 0 1-.683-.826l6.558-33.739a.695.695 0 0 1 .682-.561h7.29a.695.695 0 0 1 .683.826L64.41 48.42h5.653c4.307 0 7.227.758 8.928 2.321c1.733 1.593 2.275 4.14 1.608 7.573l-3.051 15.702a.695.695 0 0 1-.682.56h-7.407z"/><path fill="#fff" d="M65.31 38.755h-7.291a1.39 1.39 0 0 0-1.364 1.124l-6.557 33.738a1.39 1.39 0 0 0 1.363 1.654h7.291a1.39 1.39 0 0 0 1.364-1.124l3.537-18.205h4.682c2.168 0 2.624.463 2.641.484c.132.14.305.795.019 2.264l-2.9 14.927a1.39 1.39 0 0 0 1.364 1.654h7.408a1.39 1.39 0 0 0 1.363-1.124l3.051-15.7c.715-3.686.103-6.45-1.82-8.217c-1.836-1.686-4.91-2.505-9.398-2.505h-4.81l1.421-7.315a1.39 1.39 0 0 0-1.364-1.655zm0 1.39l-1.743 8.968h6.496c4.087 0 6.907.714 8.457 2.14c1.553 1.426 2.017 3.735 1.398 6.93l-3.052 15.699h-7.407l2.901-14.928c.33-1.698.208-2.856-.365-3.474c-.573-.617-1.793-.926-3.658-.926h-5.829l-3.756 19.327H51.46l6.558-33.739h7.292z"/><path d="M92.136 67.864c2.793 0 4.878-.515 6.198-1.53c1.304-1.006 2.206-2.747 2.679-5.175c.44-2.27.273-3.854-.5-4.71c-.788-.874-2.493-1.317-5.067-1.317h-4.463l-2.475 12.732zM77.54 83.547a.694.694 0 0 1-.682-.828l6.557-33.738a.695.695 0 0 1 .682-.561H98.23c4.442 0 7.748 1.206 9.826 3.585c2.089 2.39 2.734 5.734 1.917 9.935a15.878 15.878 0 0 1-1.699 4.724a15.838 15.838 0 0 1-3.128 3.92c-1.53 1.432-3.265 2.472-5.147 3.083c-1.852.604-4.232.91-7.071.91h-5.723l-1.633 8.408a.695.695 0 0 1-.683.562z"/><path fill="#fff" d="M91.555 55.826h3.891c3.107 0 4.186.682 4.552 1.089c.61.674.724 2.097.333 4.112c-.44 2.257-1.254 3.858-2.421 4.756c-1.195.92-3.139 1.386-5.773 1.386h-2.786l2.204-11.342zm6.674-8.1H84.096a1.39 1.39 0 0 0-1.363 1.123l-6.558 33.739a1.39 1.39 0 0 0 1.364 1.653h7.35a1.39 1.39 0 0 0 1.363-1.124l1.525-7.846h5.15c2.911 0 5.364-.318 7.286-.944c1.978-.642 3.797-1.731 5.408-3.238a16.52 16.52 0 0 0 3.258-4.086c.832-1.487 1.428-3.147 1.775-4.931c.86-4.423.162-7.964-2.076-10.524c-2.216-2.537-5.697-3.823-10.35-3.823zM87.666 68.557h4.47c2.964 0 5.17-.557 6.622-1.675c1.45-1.116 2.428-2.98 2.936-5.591c.487-2.508.266-4.277-.665-5.308c-.93-1.03-2.791-1.546-5.583-1.546h-5.035Zm10.563-19.445c4.251 0 7.354 1.117 9.303 3.348c1.95 2.232 2.537 5.347 1.759 9.346c-.32 1.648-.862 3.154-1.624 4.518c-.763 1.366-1.76 2.614-2.992 3.747c-1.467 1.373-3.097 2.352-4.892 2.935c-1.793.584-4.078.875-6.856.875h-6.295l-1.745 8.97h-7.35l6.558-33.739h14.133"/><defs><radialGradient id="deviconPhp0" cx="0" cy="0" r="1" gradientTransform="translate(38.426 42.169) scale(84.04136)" gradientUnits="userSpaceOnUse"><stop stopColor="#AEB2D5"/><stop offset=".3" stopColor="#AEB2D5"/><stop offset=".75" stopColor="#484C89"/><stop offset="1" stopColor="#484C89"/></radialGradient></defs></svg>
}
    href="/quickstarts/php"
  >
    Connect a PHP application to Novu.
  </Card>

  <Card
    title="Python"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="34.87" viewBox="0 0 256 255"><defs><linearGradient id="logosPython0" x1="12.959%" x2="79.639%" y1="12.039%" y2="78.201%"><stop offset="0%" stopColor="#387EB8"/><stop offset="100%" stopColor="#366994"/></linearGradient><linearGradient id="logosPython1" x1="19.128%" x2="90.742%" y1="20.579%" y2="88.429%"><stop offset="0%" stopColor="#FFE052"/><stop offset="100%" stopColor="#FFC331"/></linearGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosPython0)" d="M126.916.072c-64.832 0-60.784 28.115-60.784 28.115l.072 29.128h61.868v8.745H41.631S.145 61.355.145 126.77c0 65.417 36.21 63.097 36.21 63.097h21.61v-30.356s-1.165-36.21 35.632-36.21h61.362s34.475.557 34.475-33.319V33.97S194.67.072 126.916.072ZM92.802 19.66a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.13Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosPython1)" d="M128.757 254.126c64.832 0 60.784-28.115 60.784-28.115l-.072-29.127H127.6v-8.745h86.441s41.486 4.705 41.486-60.712c0-65.416-36.21-63.096-36.21-63.096h-21.61v30.355s1.165 36.21-35.632 36.21h-61.362s-34.475-.557-34.475 33.32v56.013s-5.235 33.897 62.518 33.897Zm34.114-19.586a11.12 11.12 0 0 1-11.13-11.13a11.12 11.12 0 0 1 11.13-11.131a11.12 11.12 0 0 1 11.13 11.13a11.12 11.12 0 0 1-11.13 11.13Z"/></svg>
}
    href="/quickstarts/python"
  >
    Connect a Python application to Novu.
  </Card>

  <Card
    title="Kotlin"
    icon={
  <svg
    xmlns="http://www.w3.org/2000/svg"
    width="20"
    height="20"
    viewBox="0 0 256 256"
  >
    <defs>
      <linearGradient
        id="logosKotlinIcon0"
        x1="99.991%"
        x2=".01%"
        y1="-.011%"
        y2="100.01%"
      >
        <stop offset=".344%" stopColor="#E44857" />
        <stop offset="46.89%" stopColor="#C711E1" />
        <stop offset="100%" stopColor="#7F52FF" />
      </linearGradient>
    </defs>
    <path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosKotlinIcon0)" d="M256 256H0V0h256L128 127.949z" />
  </svg>
}
    href="/quickstarts/kotlin"
  >
    Connect a Kotlin application to Novu.
  </Card>

  <Card
    title="Ruby"
    icon={
  <svg xmlns="http://www.w3.org/2000/svg" width="20" height="19.93" viewBox="0 0 256 255"><defs><linearGradient id="logosRuby0" x1="84.75%" x2="58.254%" y1="111.399%" y2="64.584%"><stop offset="0%" stopColor="#FB7655"/><stop offset="0%" stopColor="#FB7655"/><stop offset="41%" stopColor="#E42B1E"/><stop offset="99%" stopColor="#900"/><stop offset="100%" stopColor="#900"/></linearGradient><linearGradient id="logosRuby1" x1="116.651%" x2="1.746%" y1="60.89%" y2="19.288%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby2" x1="75.774%" x2="38.978%" y1="219.327%" y2="7.829%"><stop offset="0%" stopColor="#871101"/><stop offset="0%" stopColor="#871101"/><stop offset="99%" stopColor="#911209"/><stop offset="100%" stopColor="#911209"/></linearGradient><linearGradient id="logosRuby3" x1="50.012%" x2="66.483%" y1="7.234%" y2="79.135%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E57252"/><stop offset="46%" stopColor="#DE3B20"/><stop offset="99%" stopColor="#A60003"/><stop offset="100%" stopColor="#A60003"/></linearGradient><linearGradient id="logosRuby4" x1="46.174%" x2="49.932%" y1="16.348%" y2="83.047%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="23%" stopColor="#E4714E"/><stop offset="56%" stopColor="#BE1A0D"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby5" x1="36.965%" x2="49.528%" y1="15.594%" y2="92.478%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="18%" stopColor="#E46342"/><stop offset="40%" stopColor="#C82410"/><stop offset="99%" stopColor="#A80D00"/><stop offset="100%" stopColor="#A80D00"/></linearGradient><linearGradient id="logosRuby6" x1="13.609%" x2="85.764%" y1="58.346%" y2="-46.717%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="54%" stopColor="#C81F11"/><stop offset="99%" stopColor="#BF0905"/><stop offset="100%" stopColor="#BF0905"/></linearGradient><linearGradient id="logosRuby7" x1="27.624%" x2="50.745%" y1="21.135%" y2="79.056%"><stop offset="0%" stopColor="#FFF"/><stop offset="0%" stopColor="#FFF"/><stop offset="31%" stopColor="#DE4024"/><stop offset="99%" stopColor="#BF190B"/><stop offset="100%" stopColor="#BF190B"/></linearGradient><linearGradient id="logosRuby8" x1="-20.667%" x2="104.242%" y1="122.282%" y2="-6.342%"><stop offset="0%" stopColor="#BD0012"/><stop offset="0%" stopColor="#BD0012"/><stop offset="7%" stopColor="#FFF"/><stop offset="17%" stopColor="#FFF"/><stop offset="27%" stopColor="#C82F1C"/><stop offset="33%" stopColor="#820C01"/><stop offset="46%" stopColor="#A31601"/><stop offset="72%" stopColor="#B31301"/><stop offset="99%" stopColor="#E82609"/><stop offset="100%" stopColor="#E82609"/></linearGradient><linearGradient id="logosRuby9" x1="58.792%" x2="11.964%" y1="65.205%" y2="50.128%"><stop offset="0%" stopColor="#8C0C01"/><stop offset="0%" stopColor="#8C0C01"/><stop offset="54%" stopColor="#990C00"/><stop offset="99%" stopColor="#A80D0E"/><stop offset="100%" stopColor="#A80D0E"/></linearGradient><linearGradient id="logosRubya" x1="79.319%" x2="23.088%" y1="62.754%" y2="17.888%"><stop offset="0%" stopColor="#7E110B"/><stop offset="0%" stopColor="#7E110B"/><stop offset="99%" stopColor="#9E0C00"/><stop offset="100%" stopColor="#9E0C00"/></linearGradient><linearGradient id="logosRubyb" x1="92.88%" x2="59.841%" y1="74.122%" y2="39.704%"><stop offset="0%" stopColor="#79130D"/><stop offset="0%" stopColor="#79130D"/><stop offset="99%" stopColor="#9E120B"/><stop offset="100%" stopColor="#9E120B"/></linearGradient><linearGradient id="logosRubyc" x1="56.57%" x2="3.105%" y1="101.717%" y2="11.993%"><stop offset="0%" stopColor="#8B2114"/><stop offset="0%" stopColor="#8B2114"/><stop offset="43%" stopColor="#9E100A"/><stop offset="99%" stopColor="#B3100C"/><stop offset="100%" stopColor="#B3100C"/></linearGradient><linearGradient id="logosRubyd" x1="30.87%" x2="92.471%" y1="35.599%" y2="100.694%"><stop offset="0%" stopColor="#B31000"/><stop offset="0%" stopColor="#B31000"/><stop offset="44%" stopColor="#910F08"/><stop offset="99%" stopColor="#791C12"/><stop offset="100%" stopColor="#791C12"/></linearGradient><radialGradient id="logosRubye" cx="32.001%" cy="40.21%" r="69.573%" fx="32.001%" fy="40.21%"><stop offset="0%" stopColor="#A80D00"/><stop offset="0%" stopColor="#A80D00"/><stop offset="99%" stopColor="#7E0E08"/><stop offset="100%" stopColor="#7E0E08"/></radialGradient><radialGradient id="logosRubyf" cx="13.549%" cy="40.86%" r="88.386%" fx="13.549%" fy="40.86%"><stop offset="0%" stopColor="#A30C00"/><stop offset="0%" stopColor="#A30C00"/><stop offset="99%" stopColor="#800E08"/><stop offset="100%" stopColor="#800E08"/></radialGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby0)" d="m197.467 167.764l-145.52 86.41l188.422-12.787L254.88 51.393l-57.414 116.37Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby1)" d="M240.677 241.257L224.482 129.48l-44.113 58.25l60.308 53.528Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby2)" d="m240.896 241.257l-118.646-9.313l-69.674 21.986l188.32-12.673Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby3)" d="m52.744 253.955l29.64-97.1L17.16 170.8l35.583 83.154Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby4)" d="M180.358 188.05L153.085 81.226l-78.047 73.16l105.32 33.666Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby5)" d="m248.693 82.73l-73.777-60.256l-20.544 66.418l94.321-6.162Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby6)" d="M214.191.99L170.8 24.97L143.424.669l70.767.322Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby7)" d="m0 203.372l18.177-33.151l-14.704-39.494L0 203.372Z"/><path fill="#FFF" d="m2.496 129.48l14.794 41.963l64.283-14.422l73.39-68.207l20.712-65.787L143.063 0L87.618 20.75c-17.469 16.248-51.366 48.396-52.588 49c-1.21.618-22.384 40.639-32.534 59.73Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby8)" d="M54.442 54.094c37.86-37.538 86.667-59.716 105.397-40.818c18.72 18.898-1.132 64.823-38.992 102.349c-37.86 37.525-86.062 60.925-104.78 42.027c-18.73-18.885.515-66.032 38.375-103.558Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRuby9)" d="m52.744 253.916l29.408-97.409l97.665 31.376c-35.312 33.113-74.587 61.106-127.073 66.033Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubya)" d="m155.092 88.622l25.073 99.313c29.498-31.016 55.972-64.36 68.938-105.603l-94.01 6.29Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyb)" d="M248.847 82.833c10.035-30.282 12.35-73.725-34.966-81.791l-38.825 21.445l73.791 60.346Z"/><path fill="#9E1209" d="M0 202.935c1.39 49.979 37.448 50.724 52.808 51.162l-35.48-82.86L0 202.935Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubye)" d="M155.232 88.777c22.667 13.932 68.35 41.912 69.276 42.426c1.44.81 19.695-30.784 23.838-48.64l-93.114 6.214Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyf)" d="m82.113 156.507l39.313 75.848c23.246-12.607 41.45-27.967 58.121-44.42l-97.434-31.428Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyc)" d="m17.174 171.34l-5.57 66.328c10.51 14.357 24.97 15.605 40.136 14.486c-10.973-27.311-32.894-81.92-34.566-80.814Z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/novu-v2-docs/quickstarts#logosRubyd)" d="m174.826 22.654l78.1 10.96c-4.169-17.662-16.969-29.06-38.787-32.623l-39.313 21.663Z"/></svg>

}
    href="/quickstarts/ruby"
  >
    Connect a Ruby application to Novu.
  </Card>

  <Card
    title=".NET"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 256 256"><g fill="none"><rect width="256" height="256" fill="#512BD4" rx="60"/><path fill="#fff" d="M24.052 168.943c-2.236 0-4.138-.731-5.703-2.194c-1.566-1.501-2.349-3.283-2.349-5.347c0-2.101.783-3.902 2.349-5.403c1.565-1.5 3.466-2.251 5.703-2.251c2.274 0 4.194.751 5.76 2.251c1.603 1.501 2.404 3.302 2.404 5.403c0 2.064-.801 3.846-2.404 5.347c-1.566 1.463-3.486 2.194-5.76 2.194Zm89.415-1.238H98.929l-38.304-59.318a26.371 26.371 0 0 1-2.404-4.672h-.336c.298 1.726.447 5.422.447 11.087v52.903H45.471V87H60.96l37.018 57.912c1.566 2.402 2.572 4.052 3.02 4.953h.223c-.372-2.139-.559-5.759-.559-10.863V87h12.805v80.705Zm62.631 0h-45.014V87h43.225v11.369h-29.916v22.849h27.568v11.312h-27.568v23.863h31.705v11.312Zm63.973-69.336h-23.038v69.336h-13.309V98.369h-22.982V87h59.329v11.369Z"/></g></svg>
}
    href="/quickstarts/.NET"
  >
    Connect a .NET application to Novu.
  </Card>

  <Card
    title="NextJS"
    icon={
  <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 128 128"><path d="M64 0C28.7 0 0 28.7 0 64s28.7 64 64 64c11.2 0 21.7-2.9 30.8-7.9L48.4 55.3v36.6h-6.8V41.8h6.8l50.5 75.8C116.4 106.2 128 86.5 128 64c0-35.3-28.7-64-64-64zm22.1 84.6l-7.5-11.3V41.8h7.5v42.8z"/></svg>
}
    href="/quickstarts/nextjs"
  >
    Connect a NextJS application to Novu.
  </Card>

  <Card title="Go" icon="golang" href="/quickstarts/go">
    Connect a Go application to Novu.
  </Card>

  <Card
    title="Java"
    icon={
<svg xmlns="http://www.w3.org/2000/svg" width="35" height="35" viewBox="0 0 128 128"><path fill="#0074BD" d="M47.617 98.12s-4.767 2.774 3.397 3.71c9.892 1.13 14.947.968 25.845-1.092c0 0 2.871 1.795 6.873 3.351c-24.439 10.47-55.308-.607-36.115-5.969zm-2.988-13.665s-5.348 3.959 2.823 4.805c10.567 1.091 18.91 1.18 33.354-1.6c0 0 1.993 2.025 5.132 3.131c-29.542 8.64-62.446.68-41.309-6.336z"/><path fill="#EA2D2E" d="M69.802 61.271c6.025 6.935-1.58 13.17-1.58 13.17s15.289-7.891 8.269-17.777c-6.559-9.215-11.587-13.792 15.635-29.58c0 .001-42.731 10.67-22.324 34.187z"/><path fill="#0074BD" d="M102.123 108.229s3.529 2.91-3.888 5.159c-14.102 4.272-58.706 5.56-71.094.171c-4.451-1.938 3.899-4.625 6.526-5.192c2.739-.593 4.303-.485 4.303-.485c-4.953-3.487-32.013 6.85-13.743 9.815c49.821 8.076 90.817-3.637 77.896-9.468zM49.912 70.294s-22.686 5.389-8.033 7.348c6.188.828 18.518.638 30.011-.326c9.39-.789 18.813-2.474 18.813-2.474s-3.308 1.419-5.704 3.053c-23.042 6.061-67.544 3.238-54.731-2.958c10.832-5.239 19.644-4.643 19.644-4.643zm40.697 22.747c23.421-12.167 12.591-23.86 5.032-22.285c-1.848.385-2.677.72-2.677.72s.688-1.079 2-1.543c14.953-5.255 26.451 15.503-4.823 23.725c0-.002.359-.327.468-.617z"/><path fill="#EA2D2E" d="M76.491 1.587S89.459 14.563 64.188 34.51c-20.266 16.006-4.621 25.13-.007 35.559c-11.831-10.673-20.509-20.07-14.688-28.815C58.041 28.42 81.722 22.195 76.491 1.587z"/><path fill="#0074BD" d="M52.214 126.021c22.476 1.437 57-.8 57.817-11.436c0 0-1.571 4.032-18.577 7.231c-19.186 3.612-42.854 3.191-56.887.874c0 .001 2.875 2.381 17.647 3.331z"/></svg>
}
    href="/quickstarts/java"
  >
    Connect a Java application to Novu.
  </Card>
</CardGroup>


# PHP quickstart
Source: https://v0.x-docs.novu.co/quickstarts/php

Use Novu to send multi-channel (SMS, Email, Chat, Push) notifications from a PHP app.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications from a PHP app.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-php) if you don’t have one yet.
* A working PHP development environment with a PHP version of 7.2+.

You can also [v](https://cloudinary.com/documentation/php_quickstart#view_the_completed_code)[iew the completed code](https://github.com/novuhq/novu-php-quickstart) of this quick start in a GitHub repo.

## Install Novu PHP SDK

The [PHP SDK](http://github.com/novuhq/novu-php) provides a fluent and expressive interface for interacting with Novu's API and managing notifications.

Now install the Novu PHP SDK by running the following command in your terminal:

```bash theme={null}
composer require unicodeveloper/novu

```

Otherwise, create a file named `composer.json` and add the following to it:

```php theme={null}
{
    "require": {
        "unicodeveloper/novu": "^1.0"
    }
}

```

Next, install the SDK by running the following `composer` command:

```bash theme={null}
composer install

```

## Initialize & Configure the Novu SDK

Create a new file, `index.php` in your application and add the following code to it:

```php theme={null}
<?php

  require('vendor/autoload.php');

  use Novu\SDK\Novu;

$apiKey = '<NOVU_API_KEY>';
$novu = new Novu($apiKey);
```

Replace the `$apiKey`’s value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-php).

<Note>
  Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-php) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favourite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create A Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **Untitled.** Rename it to a more suitable title.
4. Select **Email** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added channel, fill the email subject and click “Update”.

<Frame>
  <img />
</Frame>

6. Click on the “Test” tab and send a test email to verify your workflow.

<Frame>
  <img />
</Frame>

You should get an email within seconds. Yaaay, you have successfully sent your first notification via the Novu dashboard! Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click “Subscribers” on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```php theme={null}
// Create subscriber
$novu->createSubscriber([
    'subscriberId' => '7789', // replace with system_internal_user_id
    'email' => 'abc@gmail.com',
    'firstName' => 'John', // optional
    'lastName' => 'Doe', // optional
])->toArray();
```

Run the code in your terminal like so:

```bash theme={null}
php index.php

```

You should see the subscriber on your Novu dashboard.

<Frame>
  <img />
</Frame>

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `updateSubscriber` method like so:

```php theme={null}
// Update subscriber detail
$subscriberId = '7789';
$novu->updateSubscriber($subscriberId, [
    'email' => 'validemail@gmail.com',  // replace with valid email
    'firstName' => '<insert-firstname>', // optional
    'lastName' => '<insert-lastname>', // optional
])->toArray();
```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an array of metadata that you want to attach to the subscriber.

<Note>
  To make all of your app users subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```php theme={null}
$novu->triggerEvent([
    'name' => 'first-email',
    'payload' => ['first-name' => 'Adam'],
    'to' => [
        'subscriberId' => '7789'
    ]
])->toArray();
```

Before running the code, make sure you understand the following:

* The value of `name` should be the workflow’s trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriber ID.

Run the code to trigger a notification!

```php theme={null}
php index.php

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safeguards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```php theme={null}
// Create a Topic
$novu->createTopic([
  'key'  => 'frontend-users',
  'name' => 'All frontend users'
]);
```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers to a topic:

```php theme={null}
$topicKey = 'frontend-users';
$subscribers = [
    '6460925ce1a93324257d2fc1',
    '7789'
];

// Add subscribers to a topic
$novu->topic($topicKey)->addSubscribers($subscribers);
```

On the other hand, if you want to remove subscribers from a topic, do the following:

```php theme={null}
$topicKey = 'frontend-users';
$subscribers = [
    '6460925ce1a93324257d2fc1',
    '7789'
];

// Remove subscribers from a topic
$novu->topic($topicKey)->removeSubscribers($subscribers);
```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```php theme={null}
// Send notifications to a topic (all frontend users)
$novu->triggerEvent([
    'name' => 'first-email',
    'to' => [
       [
         'type' => 'Topic',
         'topicKey' => 'frontend-users'
       ]
    ]
])->toArray();
```

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider and triggered a notification in your application.


# Python quickstart
Source: https://v0.x-docs.novu.co/quickstarts/python

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Python.

In this guide, you'll learn how to use Novu in a Python application. Let's see how you can seamlessly integrate Novu into your Python project!

## Prerequisites

Before diving into the Quickstart, make sure you have the following:

* Python3 installed on your development machine.
* A Novu account. If you don't have one, sign up for free at [web.novu.co](https://web.novu.co?utm_campaign=docs-gs-quick-python)

## Install and Set Up Novu in your Python Project

First, you must install the Novu package in your Python project. From your terminal, you can install the Novu package in your project by running either of the following two commands:

Via pip

```bash theme={null}
pip install novu

```

Via poetry

```bash theme={null}
poetry add novu

```

Once installed, you can import Novu into your project and initialize it using your Novu account credentials. This step establishes a connection between your app and the Novu notification service.

```python theme={null}
from novu.config import NovuConfig

NovuConfig().configure("https://api.novu.co", "<NOVU_API_KEY>")

```

Replace the `<NOVU_API_KEY>` value with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-python).

<Note>Please do not hardcode your credentials in a file in production. Use environment variables instead.</Note>

## Set Up A Channel Provider

A channel provider is a service that lets you use one or more notification channels such as sending an email, SMS, push notification etc. Our integration store currently supports four channels: Email, SMS, Chat, and Push. Each of these channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel** at a time. Connect anyone of your preferred providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create a Notification Workflow

A notification workflow is the blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber.

The workflow includes the following:

* Notification workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>Proper authorization needs to be set for the Chat channel for subscribers.</Note>

To create a notification workflow, please follow the following steps:

1. Click **Workflows** on the left sidebar of your Novu dashboard.

2. Click the **Add a Workflow** button on the top left.

3. Select **blank workflow** from the dropdown.

4. The name of a new workflow is currently "Untitled." Rename it to a suitable title.

5. Select any channel you want to use in your app. For the sake of this guide, we'll be using the 'Email' channel.
   <Frame>
     <img alt="Set email" />
   </Frame>

6. Click on the recently added channel, fill the email subject and click “Update”.
   <Frame>
     <img alt="Update email template" />
   </Frame>

7. Click on the “Test” tab and send a test email to verify your notification workflow.
   <Frame>
     <img alt="Send test email" />
   </Frame>

You should get an email within seconds. If you didn't, please check your 'spam' folder as sometimes test emails can end up there. Yaaay, you have successfully sent your first notification via the Novu dashboard!

Now, let’s take it a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display only one subscriber, as you were added automatically during sign-up. If default subscriber is not created, checkout [how to create new subscriber.](/subscribers/subscribers#create-a-subscriber)

<Frame>
  <img alt="Subscriber id" />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```python theme={null}
## Create a subscriber

from novu.api.subscriber import SubscriberApi
from novu.dto.subscriber import SubscriberDto

your_subscriber_id = "123" # Replace this with a unique user ID.

## Define a subscriber instance
subscriber = SubscriberDto(
   subscriber_id=your_subscriber_id,
   email="abc@gmail.com",
   first_name="John",
   last_name="Doe"
)

SubscriberApi().create(subscriber)

```

Run the code in your terminal like so:

```bash theme={null}
python main.py # replace main.py with your file name

```

You should see a new subscriber (that you created above) on your Novu dashboard.

## Update A Subscriber

To update the Subscriber details you can call the put method from SubcriberApi. Here is an example:

```python theme={null}
## Update subscriber detail

from novu.api.subscriber import SubscriberApi
from novu.dto.subscriber import SubscriberDto

subscriber = SubscriberDto(
   subscriber_id="123",
   email="new.abc@gmail.com",
   first_name="New",
   last_name="Name"
)

SubscriberApi().put(subscriber)

```

<Note>To send notifications to all your users, you'll need to make them subscribers in Novu, which you can do by programmatically adding them to Novu.</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```python theme={null}
from novu.api import EventApi

EventApi().trigger(
    name="test",  # The trigger ID of the workflow. It can be found on the workflow page.
    recipients="123",
    payload={},  # Your Novu payload goes here
)

```

Before running the code, make sure you understand the following:

* The value of `name` should be the notification workflow's trigger ID/slug.

<Frame>
  <img alt="Trigger id" />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the notification template content.
* The value of `recipients` is the id of the subscriber on Novu. Replace `123` with your subscriber ID.

Run the code to trigger a notification!

```bash theme={null}
python main.py # replace main.py with your file name

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```python theme={null}
from novu.api import TopicApi

## Create a topic
TopicApi().create(
    key="new-customers", name="New business customers"
)

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add subscribers to a Topic

Copy and paste the following code into your app to add subscribers a topic:

```python theme={null}
from novu.api import TopicApi

## Add a list of subscribers to a topic
TopicApi().subscribe(key="new-customers", subscribers="<LIST_OF_SUBSCRIBER_IDs>")

```

On the other hand, if you want to remove subscribers from a topic, do the following:

```python theme={null}
from novu.api import TopicApi

## Unsubscribe a list of subscribers from a topic
TopicApi().unsubscribe(key="new-customers", subscribers="<LIST_OF_SUBSCRIBER_IDs>")

```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```python theme={null}
from novu.api import EventApi
from novu.dto.topic import TriggerTopicDto

topics = TriggerTopicDto(
   topic_key="new-customers",
   type="Topic",
)

EventApi().trigger_topic(
    name="test",  # The trigger ID of the workflow. It can be found on the workflow page.
    topics=topics,
    payload={},  # Your Novu payload goes here
)

```

## Next Steps

Great job! If you've reached this point, you should now have successfully set up a channel provider, created a notification workflow, created a subscriber, updated a subscriber and triggered a notification in your application.

To learn more about notifications and explore Novu's features and capabilities, check out:

* [Novu Digest Engine](/workflows/digest) - Learn how to aggregate multiple trigger events into a single message and deliver it to the subscriber.
* [Novu Python SDK](https://github.com/novuhq/novu-python) - Delve deeper into the SDK and explore a lot of features.
* [Novu Python Cookbook](https://novu-python.readthedocs.io/en/latest/) - Learn how to use the SDK features.


# React
Source: https://v0.x-docs.novu.co/quickstarts/react

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with React.

Send notifications across different channels (SMS, Email, Chat, Push) and enable real-time In-App notifications with the help of a rich and customizable Notification Center.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-react) if you don’t have one yet.
* A working React development environment.

You can find the code for this project [here](https://github.com/novuhq/react-quickstart)

## Install the Novu React Notification Center Package in your React app

The Novu React package provides a React component library that you can use to add a fully functioning notification center to your React application.

To use it, first, install the React Notification Center package by running the following command in your terminal:

```bash theme={null}
npm install @novu/notification-center

```

Before you can use Novu in your React app, you'll need two things:

1. Create a workflow to use for sending notifications, and
2. Create a subscriber - recipient of notifications.

## Create a workflow

Before triggering a notification, we need to create a workflow. A workflow is like a blueprint that all the notifications are supposed to follow.

> The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

These are the steps to create a workflow:

1. Click **Workflow** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently **"Untitled"**. Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.

   <Frame>
     <img />
   </Frame>
5. Click on the recently added "In-App" channel and configure it according to your preferences. Once you're done, click "Update" to save your configuration.

   <Frame>
     <img />
   </Frame>

   I'll briefly explain the function of each label in the image above:

* **1-Preview**: This shows you a glimpse of how each notification item will look in the Notification Center UI.
* **2-Avatar**: If turned on, each notification item will show the avatar of the subscriber.
* **3-Action**: With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds**: This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL**: This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter**: This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).
* **7-Editor**: You can add text that you want to be displayed in each notification item. Additionally, you can specify custom variables using `{{ }}`. This means you can inject variables from your code into a notification item's text via a payload.

In our case, we'll use the custom variables functionality, as shown below:

<Frame>
  <img />
</Frame>

Feel free to add only text for now and rename the workflow to quick start. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

<Frame>
  <img />
</Frame>

Now, we’ll learn how to create subscribers on Novu - Recipients of Notifications!

## Create a subscriber

If you click “Subscriber” on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-react), you’ll see the subscriber list. By default, there will only be one subscriber as you’re automatically added as a subscriber when you sign up for Novu:

<Frame>
  <img />
</Frame>

<Note>If you don't see the default subscriber, follow [how to create subscriber](/subscribers/subscribers#create-a-subscriber) documentation to learn on how to create one </Note>

Now, let’s create a subscriber on Novu. After creating a subscriber, we’ll trigger a notification to this subscriber. Subscribers are identified by a unique `subscriberId`.

With Novu, you can create a subscriber using any of its SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin). The NodeJS code to create a subscriber in Novu is:

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<NOVU_API_KEY>");

await novu.subscribers.identify("789", {
  firstName: "Sumit",
  lastName: "Saurabh",
});
```

The `identify` method used above either updates an existing subscriber using the payload data if a subscriber with the same `subscriberId` already exists, or creates a new one if it doesn't. Here, since no subscriber with `firstName` of `Sumit` and `lastName` of `Saurabh` exists, a new one was created and we can now send a notification to this subscriber by triggering a workflow.

<Info>
  You can read more about the `identify` method in our
  [docs](https://docs.novu.co/subscribers/subscribers#create-a-subscriber)
</Info>

You can get your API key from the Novu dashboard. Replace `<NOVU_API_KEY>` with it. Now, head over to the Novu dashboard and see the newly created subscriber above with a `subscriberId` of `789`.

You can also update information about an already existing subscriber using the `subscriber.update` method as shown below:

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<NOVU_API_KEY>");

await novu.subscribers.update("789", {
  firstName: "Saurabh", // new first name
  lastName: "Sumit", // new last name
});
```

## Using Novu in a React app

We have already installed the Novu notification center package above. To use it in an app, simply import it and add the component to your React app as follows:

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
} from "@novu/notification-center";

function App() {
  return (
    <>
      <NovuProvider
        subscriberId={process.env.REACT_APP_SUB_ID}
        applicationIdentifier={process.env.REACT_APP_APP_ID}
      >
        <PopoverNotificationCenter>
          {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
        </PopoverNotificationCenter>
      </NovuProvider>
    </>
  );
}

export default App;
```

You'll notice two things used above - `applicationIdentifier` and `subscriberID`.

An application identifier is a public key used to identify your application. You can get your own application identifier from the [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-react).

And subscribers are users to whom notifications will be sent. They are identified by a `subscriberID` which you can also find in the [Novu subscribers dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-react).

## Trigger a notification

We can trigger a notification by simply running the code below with the correct credentials;

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<API_KEY>");

novu.trigger("quickstart", {
  to: {
    subscriberId: "789",
  },
  payload: {
    description: "Test notification",
  },
});
```

This will take the workflow we created above with the identifier `quickstart` and send a notification to the subscriber with `subscriberId` of `789`.

> Make sure you're executing this code with the correct credentials.

## Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification centre, created a subscriber, a workflow, and triggered a notification in your React application.


# RedwoodJS
Source: https://v0.x-docs.novu.co/quickstarts/redwoodjs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with RedwoodJS.

Send notifications across different channels (SMS, Email, Chat, Push) and enable real-time In-App notifications with the help of a rich and customizable Notification Center in a RedwoodJS app.

Explore the code for [this quickstart on GitHub](https://github.com/novuhq/redwoodjs-quickstart/).

Explore the [live demo](https://novu-redwoodjs-blog.netlify.app/contact).

# Prerequisites

To follow the steps in this quickstart, you'll need:

* A Novu account. If you don't have one, [sign up for free](https://web.novu.co?utm_campaign=docs-gs-quick-redwoodjs).
* Node.js installed on your development machine.

# Create a RedwoodJS app

Clone the popular RedwoodJS blog tutorial app by running the following command in your terminal:

```bash theme={null}
git clone https://github.com/redwoodjs/redwood-tutorial
cd redwood-tutorial
yarn install
yarn rw prisma migrate dev
yarn rw prisma db seed
yarn rw dev

```

# Install Novu

To install Novu's In-App notification center, simply issue the following command:

```bash theme={null}
yarn workspace web add @novu/notification-center

```

Next, install Novu's Node SDK to fire notifications from the api/backend:

```bash theme={null}
yarn workspace api add @novu/node

```

## Register The Notification Center Component

Head over to `web/src/layouts/BlogLayout/BlogLayout.js` file of the recently cloned project and add the Novu In-App Notification center.

The file should look like this:

```javascript theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
} from "@novu/notification-center";

import { Link, routes } from "@redwoodjs/router";

import { useAuth } from "src/auth";

const BlogLayout = ({ children }) => {
  const { logOut, isAuthenticated, currentUser } = useAuth();
  const SUBSCRIBER_ID = process.env.REDWOOD_ENV_SUBSCRIBER_ID;
  const APPLICATION_IDENTIFIER = process.env.REDWOOD_ENV_APPLICATION_IDENTIFIER;

  return (
    <>
      <header className="relative flex justify-between items-center py-4 px-8 bg-blue-700 text-white">
        <h1 className="text-5xl font-semibold tracking-tight">
          <Link
            className="text-blue-400 hover:text-blue-100 transition duration-100"
            to={routes.home()}
          >
            Redwood Blog with <em>Novu</em>
          </Link>
        </h1>
        <nav>
          <ul className="relative flex items-center font-light">
            <li>
              <NovuProvider
                subscriberId={SUBSCRIBER_ID}
                applicationIdentifier={APPLICATION_IDENTIFIER}
              >
                <PopoverNotificationCenter
                  showUserPreferences={true}
                  position="top-start"
                >
                  {({ unseenCount }) => (
                    <NotificationBell unseenCount={unseenCount} />
                  )}
                </PopoverNotificationCenter>
              </NovuProvider>
            </li>
            <li>
              <Link
                className="py-2 px-4 hover:bg-blue-600 transition duration-100 rounded"
                to={routes.about()}
              >
                About
              </Link>
            </li>
            <li>
              <Link
                className="py-2 px-4 hover:bg-blue-600 transition duration-100 rounded"
                to={routes.contact()}
              >
                Contact
              </Link>
            </li>
            <li>
              {isAuthenticated ? (
                <div>
                  <button type="button" onClick={logOut} className="py-2 px-4">
                    Logout
                  </button>
                </div>
              ) : (
                <Link to={routes.login()} className="py-2 px-4">
                  Login
                </Link>
              )}
            </li>
          </ul>
          {isAuthenticated && (
            <div className="absolute bottom-1 right-0 mr-12 text-xs text-blue-300">
              {currentUser.email}
            </div>
          )}
        </nav>
      </header>
      <main className="max-w-4xl mx-auto p-12 bg-white shadow rounded-b">
        {children}
      </main>
    </>
  );
};

export default BlogLayout;
```

<Note>
  Add `REDWOOD_ENV_APPLICATION_IDENTIFIER` and `REDWOOD_ENV_SUBSCRIBER_ID` to
  the `.env` file.
</Note>

The `Subscriber ID` ideally should be the `id` of the **logged in user**. When a user logs into your app, they’ll be able to see all their notifications in the notification center. For this to work successfully, the user should have been created as a subscriber on Novu.

The `Application Identifier` is a public key used to identify your application.

Head over to your [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-redwoodjs), copy the application identifier and add it as the value of `REDWOOD_ENV_APPLICATION_IDENTIFIER`.

Head over to [the Subscribers page](https://web.novu.co/subscribers?utm_campaign=docs-quick-redwoodjs), grab a subscriber identifier and add it as the value of `REDWOOD_ENV_SUBSCRIBER_ID` in the `.env` file.

Now, check your app, you will see a notification bell button. Click on the button to reveal the notification center UI. Voila!

<Note>
  There are no notifications because none has been triggered yet. When
  notifications are sent to a subscriber, it will show up in the UI. Next, we'll
  learn how to trigger notifications.
</Note>

# Create A Workflow

The first step to trigger notifications is to create a workflow. A workflow is like a map that holds the entire flow of messages sent to the subscriber.

<Note>The recipients of a triggered notification are called subscribers.</Note>

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Add a workflow** button on the top left.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.
5. Click on the recently added In-App channel and configure it.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).

In the In-App channel `Editor`, add the following content and rename the step to `Onboarding In App` :

```javascript theme={null}
Hi {{ name }},
<br/>
<p>Thanks for indicating interest in attending RedwoodJS conference. Here is your message: </p>

<p>{{ message }}</p>

```

<Note>
  `{{ name }}` and `{{ message }}` are payload values that will be passed on from
  our code to the workflow template so it can appear in the notification sent to
  subscribers.
</Note>

Click on the `Update` button to save the configuration successfully!

6. In the workflow page, drag and drop the **Email** channel to the workflow canvas to be just below the `In-App` channel.
7. Click on the recently added Email channel and configure it:

Add `Sender name` and `Subject`. Ensure the `Default Layout` is selected for the Email Layout.

Switch to the `Custom Code` section and add the following:

```javascript theme={null}
Hi {{ name }},

<br />
<p>Thank you for attending RedwoodJS Conference. This means a lot to us!</p>
<br />
<p>Here is your message:</p>

{{ message }}

```

Finally, give the workflow a name. We'll need the workflow trigger identifier ***(which is the slug of the name)*** later.

Next, we’ll learn how to trigger notifications to subscribers.

# Trigger A Notification

Open up `api/src/services/contacts/contacts.js`, and add the following code into your app to trigger a notification:

```javascript theme={null}
import { Novu } from '@novu/node'

const novu = new Novu(process.env.NOVU_API_KEY)

export async function sendNotification(email, name, message) {
  await novu.trigger('<workflow-trigger-id>', {
    to: {
      subscriberId: process.env.REDWOOD_ENV_SUBSCRIBER_ID,
      email: email,
    },
    payload: {
      name: name,
      message: message,
    },
  })
}

...

...

/** In the createContact code, call the sendNotification and pass in the email, name and message */
export const createContact = ({ input }) => {
  validate(input.email, 'email', { email: true })

  sendNotification(input.email, input.name, input.message)

  return db.contact.create({
    data: input,
  })
}

...
...

```

Before running the code, make sure you understand the following:

* The value of `<workflow-trigger-id>` should be the workflow’s trigger ID/slug.
* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu.
* Ensure `NOVU_API_KEY` is in the `.env` file and with the appropriate value gotten from the dashboard.

# One more thing

Head over to the [integrations store on your Novu dashboard](https://web.novu.co/integrations?utm_campaign=docs-quick-redwoodjs).

Select the **Novu Email Test Provider**, and mark as the primary provider for Emails. This ensures that all emails are sent via the Novu Email provider.

# Test the app

Ensure your app is still running and head over the `/contact` page in the app. Fill the form and click `Save`.

The app will trigger two notifications:

* An In-App notification
* An Email notification

# Conclusion

Great job! If you've reached this point, you should now have successfully created workflow, configured a channel provider, triggered a workflow, and sent an email and In-App notification.


# Ruby quickstart
Source: https://v0.x-docs.novu.co/quickstarts/ruby

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Ruby.

Learn how to integrate Novu into your Ruby project on the fly and send notifications across different channels (SMS, Email, Chat, Push).

Let's get started! 💪

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-ruby) if you don’t have one yet.
* A working Ruby development environment with at least version 2.6.0.

You can also [view the completed code](https://github.com/novuhq/novu-ruby-quickstart) of this quick start in a GitHub repo.

## Install Novu Ruby SDK

The [Ruby SDK](http://github.com/novuhq/novu-ruby) provides a fluent and expressive interface for interacting with Novu's API and managing notifications.

You can install the client library via RubyGems:

```ruby theme={null}
gem install novu

```

Or add it to your Gemfile:

```ruby theme={null}
gem 'novu'

```

Then run `bundle install`.

## Initialize & Configure the Novu Ruby SDK

To use the library, Create a new file `index.rb` then initialize the client with your API token:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

```

Replace the `<NOVU_API_KEY>` argument with the authentic key from the **API Key** section of your [Novu Dashboard](https://web.novu.co/settings?utm_campaign=docs-quick-ruby).

<Note>
  Please do not hardcode your credentials in a file in production. Use environment variables instead.
</Note>

To test your API key, call the methods on the client to interact with the Novu API and display the result on your ruby console:

```ruby theme={null}
puts client.notifications

```

Run the file `index.rb`:

```bash theme={null}
ruby index.rb

```

You should see a result as below:

```json theme={null}
{
  "page": 0,
  "totalCount": 0,
  "pageSize": 10,
  "data": []
}

```

## Set Up A Channel Provider

A channel provider is a service that provides one or more notification functionality such as sending an email, SMS, push notification etc. Our [integration store](https://web.novu.co/integrations?utm_campaign=docs-quick-ruby) includes four channels: Email, SMS, Chat, and Push. These channels have multiple providers associated with them.

| Channel | Providers                                                           |
| ------- | ------------------------------------------------------------------- |
| Email   | MailGun, Mandrill, MailJet, Amazon SES, Sendgrid, Postmark, Netcore |
| SMS     | Twilio, Amazon SNS, Plivo, SMS, SMSCentral, Kannel, Infobip, Termii |
| Chat    | Mattermost, Slack, Microsoft Teams, Discord                         |
| Push    | FCM, APNS, Expo                                                     |

Only one provider can be **active** per **channel**. Connect any of your favorite providers to get started. The email channel comes with Novu's email provider, which is active by default and includes 300 credits.

## Create A Workflow

A workflow is a blueprint for the notifications that will be sent. It holds the entire flow of messages sent to the subscriber. This is where all the different channels are tied together under a single entity.

The workflow includes the following:

* Workflow name and Identifier
* Channel-tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

<Note>
  Proper authorization needs to be set for the Chat channel for subscribers.
</Note>

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.

<Frame>
  <img />
</Frame>

3. The name of the new workflow is currently Untitled, rename it to a more suitable title.

<Frame>
  <img />
</Frame>

4. Select Email as the channel you want to add, by dragging it from the right sidebar.

<Frame>
  <img />
</Frame>

5. Click on the Email in the workflow and edit it as per this image. Don’t forget to add the fields in the editor which is supposed to be updated with dynamic values that will be sent when calling the API.

<Frame>
  <img />
</Frame>

6. Also, add the variables in the Variables section in the test tab and try testing it by sending the email to your email address using the Send Test Email button at the bottom right.

<Frame>
  <img />
</Frame>

You should get an email within seconds! 👌

Great, you have successfully sent your first notification via the Novu dashboard! Now, let’s take a step further to trigger notifications via code.

## Create A Subscriber

The recipients of a triggered notification are called subscribers.

Click **Subscribers** on the left sidebar of the Novu dashboard to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu. Copy and paste the following code to do so:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## Create subscriber

create_payload = {
    'subscriberId' => '7789', # replace with system_internal_user_id
    'firstName' => 'John', # optional
    'lastName' => 'Doe', # optional
}
client.create_subscriber(create_payload)

```

Run the code in your terminal:

```bash theme={null}
ruby index.rb

```

You should see the subscriber on your Novu dashboard.

\![https://res.cloudinary.com/dxc6bnman/image/upload/f\_auto,q\_auto/v1685466979/guides/Screenshot\_2023-05-14\_at\_11.06.38\_ugvmc0.png](https://res.cloudinary.com/dxc6bnman/image/upload/f_auto,q_auto/v1685466979/guides/Screenshot_2023-05-14_at_11.06.38_ugvmc0.png)

I’d like to publicly announce that `abc@gmail.com` is a random unlikely email your users will have. To update this to an alternative email, you can call the `updateSubscriber` method like so:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## Update subscriber detail

update_payload = {
    'email' => 'validemail@gmail.com',  # replace with valid email
    'firstName' => '<insert-firstname>', # optional
    'lastName' => 'Obasanjo', # optional
}
client.update_subscriber('7789', update_payload);
```

Other valid fields that can be updated are `phone`, `avatar`, and `data`. The `data` field can accept an object of metadata that you want to attach to the subscriber.

<Note>
  To make all of your app users subscribers, you need to programmatically add them to Novu.
</Note>

## Trigger A Notification

Copy and paste the following code into your app to trigger a notification:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## trigger a notification

trigger_payload = {
    'name' => 'Trigger1',
    'payload' => {
        'first-name' => 'Adam'
    },
    'to' => {
        'subscriberId' => '7789'
    }
}
client.trigger_event(trigger_payload)

```

Before running the code, make sure you understand the following:

* The value of `name` should be the workflow’s trigger ID/slug.

<Frame>
  <img />
</Frame>

* The value of `payload` is an array of the data that you want to be dynamically injected into the workflow content.
* The value of `subscriberId` is the id of the subscriber on Novu. Replace `7789` with your subscriber ID.

Run the code to trigger a notification!

```bash theme={null}
ruby index.rb

```

Next, we’ll learn how to send notifications to different groups of subscribers easily via **Topics.**

## Topics

Novu provides a simple API that offers an easy interface for triggering notifications to multiple subscribers at once. This API is called **Topics** and allows users to manage their bulk notifications without having to implement complex loops.

A topic is identified by a custom key and this key will be the identifier used when triggering notifications. You can assign a name to a topic for descriptive purposes. This name does not need to be unique and can be changed programmatically.

<Note>
  The topic key should be unique and can't be changed once chosen. Novu also safeguards for key uniqueness behind the scenes.
</Note>

A topic can have multiple subscribers who will receive a notification whenever a message is sent to the topic.

## Create a Topic

Copy and paste the following code into your app to create a topic:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')
## Create a Topic

create_topic_payload = {
    'key'  => 'frontend-users',
    'name' => 'All frontend users'
}
client.create_topic(create_topic_payload)

```

Before running the code, make sure you understand the following:

* When creating a `key`, ensure it is unique and accurately identifies the topic. Document naming conventions and communicate them to team members to avoid confusion and ensure a smooth workflow.
* The value of `name` should be a descriptive topic name.

## Add and Remove Subscribers to a Topic

Copy and paste the following code into your app to add subscribers to a topic:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

topicKey = 'frontend-users'
subscribers = ['6460925ce1a93324257d2fc1', '7789'].to_s

## Add subscribers to a topic
client.add_subscribers(topicKey, subscribers)

```

Also, you can remove subscribers from a topic by using the code snippet below:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

topicKey = 'frontend-users'
subscribers = ['6460925ce1a93324257d2fc1', '7789'].to_s

## Remove subscribers from a topic
client.remove_subscribers(topicKey, subscribers)

```

## Sending a notification to a Topic

Thanks to the topics feature, it is possible to trigger a notification to all subscribers assigned to a topic. This helps avoid listing all subscriber identifiers in the `to` field of the notification trigger.

To trigger a notification to all subscribers of a topic, copy and paste the code below:

```ruby theme={null}
require 'novu'

client = Novu::Client.new('<NOVU_API_KEY>')

## Send notifications to a topic (all frontend users)
client.trigger_event({
    'name' => 'Trigger1',
    'to' => {
        'type' => 'Topic',
        'topicKey' => 'frontend-users'
    }
})

```

<Note>
  The value of the `name` key in the payload should be the name of the notification created earlier.
</Note>

## Conclusion

Great job! If you've reached this point, you should now have successfully created a subscriber, workflow, configured a channel provider and triggered a notification in your application.


# VanillaJS
Source: https://v0.x-docs.novu.co/quickstarts/vanillajs

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with VanillaJS.

Learn how to integrate Novu into your vanilla JS app on the fly. Send notifications across different channels (SMS, Email, Chat, Push) and enable real-time In-App notifications with the help of a rich and customizable Notification Center.

## Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-vanilla) if you don’t have one yet.
* A working Vanilla JS development environment.

You can find the code for this project [here](https://github.com/novuhq/vanillajs-quickstart)

## Loading Notification center component from the CDN

The Notification Center Web Component is a custom element that can be used in any web application.

You can find out more about the web component [here](https://docs.novu.co/notification-center/web-component/).

In our case, we'll be using the bundled version of the Notification Center Web Component that is available on the CDN.

You can load the Notification center component using the CDN as follows:

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    ...
    <!-- CDN link for Novu notification center component -->
    <script src="​https://web-component.novu.co/index.js"></script>
  </head>
  <body>
    <!-- HTML body -->
    <!-- the notification center -->
    <notification-center-component
      style="display: inline-flex"
      application-identifier="<YOUR_APPLICATION_IDENTIFIER>"
      subscriber-id="<YOUR_SUBSCRIBER_ID>"
    ></notification-center-component>
  </body>
</html>

```

You'll notice the use of two things in the above code - `application-identifier` and `subscriber-id`.

An application identifier is a public key used to identify your application. You can get your own application identifier from the [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-vanilla).

And subscribers are users to which notifications will be sent. They are identified by a `subscriberID` which you can also find in the [Novu subscribers dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-vanilla). Let's learn more about subscribers.

## Subscribers in Novu

If you click “Subscriber” on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-vanilla), you’ll see the subscriber list. By default, there will only be one subscriber as you’re automatically added as a subscriber when you sign up for Novu:

<Frame>
  <img />
</Frame>

<Note>If you don't see the default subscriber, follow [how to create subscriber](/subscribers/subscribers#create-a-subscriber) documentation to learn on how to create one </Note>

Now, let’s create a subscriber on Novu. After creating a subscriber, we’ll trigger a notification to this subscriber. Subscribers are identified by a unique `subscriberId`.

With Novu, you can create a subscriber using any of its SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin). The code to create a subscriber in Novu is:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.identify('123', {
  firstName: 'Sumit',
  lastName: 'Saurabh',
  returnUser: true,
});
```

You can get your API key from the Novu dashboard. Replace `<NOVU_API_KEY>` with it. Now, if you’ll go to the Novu dashboard, you shall see the subscriber we created above with `subscriberId` of `123`.

You can also update information about an already existing subscriber using the `subscriber.update` method as shown below:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('123', {
  firstName: 'Saurabh', // new first name
  lastName: 'Sumit', // new last name
});
```

## Create a workflow

Before triggering a notification, we need to create a workflow. A workflow is like a blueprint that all the notifications are supposed to follow.

> The recipients of a triggered notification are called subscribers.

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

These are the steps to create a workflow:

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **"Create Workflow"** button on the top right.
3. The name of the new workflow is currently **"Untitled"**. Rename it to a more suitable title.
4. Select **"In-App"** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added In-App channel and configure it according to your preferences. Once you’re done, click Update to save your configuration.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.

In our case, we'll use the custom variables functionality, as shown below:

<Frame>
  <img />
</Frame>

Feel free to add only text for now and rename the workflow to quickstart. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

Having created a workflow and having our `subscriberID`, we're ready to send notifications using Novu!

## Using Novu in a vanilla JS app

We have already used the CDN to get the notification center component and we already have all the credentials that we need. To use it in an app, simply use the `notification-center-component` in your html file as shown below.

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    ...
    <!-- CDN link for Novu notification center component -->
    <script src="​https://web-component.novu.co/index.js"></script>
  </head>
  <body>
    <notification-center-component
      style="display: inline-flex"
      application-identifier="<YOUR_APPLICATION_IDENTIFIER>"
      subscriber-id="<YOUR_SUBSCRIBER_ID>"
    ></notification-center-component>

    <script>
      // here you can attach any callbacks, interact with the web component API
      // You can also move this to a separate js file and have all the callbacks and other logic there
      let nc =document.getElementsByTagName('notification-center-component')[0];
      nc.onLoad = () => console.log('hello world!');
    </script>
  </body>
</html>
```

You can add all the logic you want to add to the `script` element at the bottom or move it all into a separate JavaScript file (don't forger to link to the JavaScript file in this case).

Here's an example of such an HTML file:

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <script src="​https://web-component.novu.co/index.js"></script>

    <title>Vanilla JS app</title>
  </head>

  <body>
    <div>
      <h1>Notification generator</h1>
      <notification-center-component
        style="display: inline-flex"
        application-identifier="<YOUR_NOVU_APPLICATION_IDENTIFIER>"
        subscriber-id="123"
      ></notification-center-component>
    </div>
    <div class="">
      <form action="#" method="post" class="form">
        <input class="input" placeholder="Enter notification text" type="text" name="description" />
        <button class="btn">Send</button>
      </form>
    </div>
  </body>
  <script src="./app.js"></script>
</html>
```

And the corresponding script file is as follows:

```jsx theme={null}
const btn =document.querySelector('.btn');
const input =document.querySelector('.input');
const form =document.querySelector('.form');

const onClickHandler = async (e) => {
  e.preventDefault();
  const desc = input.value;
  console.log(desc);
  try {
    const resp = await fetch('<The API route from your backend>', {
      method: 'POST',
      body: JSON.stringify({
        description: desc,
      }),
      headers: {
        'Content-Type': 'application/json',
      },
    });
    input.value = '';
    console.log(resp);
  } catch (err) {
    console.log(err);
  }
};

form.addEventListener('submit', onClickHandler);

// here you can attach any callbacks, interact with the web component API
let nc =document.getElementsByTagName('notification-center-component')[0];
nc.onLoad = () => console.log('hello world!');
```

The front-end as well as the back-end code for the sample application can be found [here](https://github.com/novuhq/vanillajs-quickstart) for illustration.

## Code to trigger the notification

We can trigger a notification by simply executing the trigger code snippet we get from the Novu web dashboard.

To get the snippet:

1. Go to **Workflows** in the left sidebar on Novu web dashboard.
2. Select the workflow.
3. Click the **Get Snippet** button on the top right.

Here's the trigger snippet you'll receive:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<API_KEY>');

novu.trigger('quickstart', {
  to: {
    subscriberId: '<REPLACE_WITH_DATA>',
  },
  payload: {
    description: '<REPLACE_WITH_DATA>',
  },
});
```

> Make sure you're executing this code with the correct credentials.

## Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, configured a channel provider and triggered a notification in your React application.


# Vue
Source: https://v0.x-docs.novu.co/quickstarts/vue

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications with Vue.

Learn how to use Novu to quickly send multi-channel (SMS, Email, Chat, Push) notifications and integrate a rich, customizable and ready-to-use realtime UI In-App notification center in Vue apps.

# Requirements

To follow the steps in this quickstart, you'll need:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-quick-vue) if you don’t have one yet.
* A working Vue development environment with a Vue 3 version.

You can also [view the completed code](https://github.com/novuhq/vue-quickstart) of this quick start in a GitHub repo.

# Create a new Vue app

If you already have a working Vue app, please feel free to skip this section.

Create a new Vue 3 app by running the following command in your terminal:

```bash theme={null}
npx create-vue notifications-app
```

Interactively run through the questions and answer them according to your preference. Then `cd` into the `notifications-app` folder and run the following:

```bash theme={null}
npm install && npm run format && npm run dev
```

# Install Novu Vue Notification Center Package

The Novu Vue package provides a Vue component wrapper over the web component that you can use to integrate the notification center into your Vue application.

Now install the Vue Notification Center package by running the following command in your terminal:

```bash theme={null}
npm install @novu/notification-center-vue
```

## Register The Notification Center Plugin

First, register the notification center plugin in your app as a global component.

In your `main.js` or `main.ts` file, add it like so:

```tsx theme={null}
import { createApp } from 'vue';

import NotificationCenterPlugin from '@novu/notification-center-vue';
import '@novu/notification-center-vue/dist/style.css';

// your app component
import App from './App.vue';

const app = createApp(App);

app.use(NotificationCenterPlugin);
app.mount('#app');
```

# Use The Notification Center Component

Create a new file, `NotificationCenter.vue` in the `src/components` directory. This file will house the Notification Center component.

Add the `NotificationCenterComponent` like so:

***Using the Composition API***

```tsx theme={null}
<script lang="ts" setup>
    const subscriberId = 'INSERT_SUBSCRIBER_ID_HERE'
    const applicationIdentifier = import.meta.env.NOVU_APP_IDENTIFIER
    const sessionLoaded = () => {
        console.log("Notification Center session loaded successfully!")
    }
</script>

<template>
    <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>
```

src/components/NotificationCenter.vue

***Using the Options API***

```tsx theme={null}
<script lang="ts">
export default {
  data() {
    return {
      applicationIdentifier: import.meta.env.VITE_NOVU_APP_IDENTIFIER,
      subscriberId: 'INSERT_SUBSCRIBER_ID_HERE',
    };
  },
  methods: {
    sessionLoaded() {
      console.log('Session loaded!')
    },
  },
};
</script>

<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>
```

src/components/NotificationCenter.vue

The `subscriberId` ideally should be the `id` of the **logged in user**. When a user logs into your app, they’ll be able to see all their notifications in the notification center. For this to work successfully, the user should have been created as a subscriber on Novu.

The `applicationIdentifier` is a public key used to identify your application. Obtain it from your [Novu dashboard settings](https://web.novu.co/settings?utm_campaign=docs-quick-vue), and add it to your `.env` file.

If there’s none, create a `.env` file and add it like so:

```
VITE_NOVU_APP_IDENTIFIER = YOUR_NOVU_APP_IDENTIFIER;
```

Replace `YOUR_NOVU_APP_IDENTIFIER` with the real value from your dashboard.

# Display The In-App Notification Center UI

If you started by creating a new Vue app, then do the following:

Head over to `src/views/HomeView.vue` and import the `NotificationCenter.vue` component.

Replace the entire file with the code below:

```tsx theme={null}
<script setup lang="ts">
import NotificationCenter from '../components/NotificationCenter.vue'
</script>

<template>
  <main>
    <NotificationCenter />
  </main>
</template>
```

src/views/HomeView\.vue

Run your app again. You will see a button with the text **Notifications: 0**. Click on the button to reveal the notification center UI. Voila!

<Note>
  There are no notifications because none has been triggered yet. When notifications are sent to a subscriber, it will show up in the UI. Next, we'll learn how to trigger notifications.
</Note>

There’s a probability you might want the general notification bell icon. By default, the component displays the bell icon.

Simply delete the button element. Your component should look like this:

```jsx theme={null}
<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
  </NotificationCenterComponent>
</template>
```

You should now see a **bell button** that opens the notification center when clicked. This bell can be customized to your preference, and we will style and modify it in a later step.

* [Vue Notification Center Example Repo](https://github.com/novuhq/examples/tree/main/vue-notification-center-example)

# Create A Workflow

The first step to trigger notifications is to create a workflow. A workflow is like a map that holds the entire flow of messages sent to the subscriber.

<Note>
  The recipients of a triggered notification are called subscribers.
</Note>

The workflow includes the following:

* Workflow name and Identifier
* Channel tailored content:

| Channel<br /><br /> | Content Style<br /><br /> | Custom Variables<br />`{{handlebars}}` format |
| ------------------- | ------------------------- | :-------------------------------------------: |
| **Email**           | HTML                      |                       ✅                       |
|                     | Visual Editor             |                       ✅                       |
| **SMS**             | Text                      |                       ✅                       |
| **Chat**            | Text                      |                       ✅                       |
| **In-App**          | Text                      |                       ✅                       |
| **Push**            | Text                      |                       ✅                       |

Please proceed to create a workflow.

1. Click **Workflows** on the left sidebar of your Novu dashboard.
2. Click the **Create Workflow** button on the top right.
3. The name of the new workflow is currently "Untitled." Rename it to a more suitable title.
4. Select **In-App** as the channel you want to add.

<Frame>
  <img />
</Frame>

5. Click on the recently added In-App channel and configure it according to your preferences. Once you’re done, click Update to save your configuration.

<Frame>
  <img />
</Frame>

I’ll briefly explain the function of each label in the image above.

* **1-Preview**: Shows you a glimpse of how each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour. Read [more about filters](https://docs.novu.co/platform/step-filter/#subscriber-seen--read-filters).

Feel free to add only text for now and rename the workflow to `Onboarding In App`. It automatically creates a slug-like Identifier that will be needed in later steps to trigger a notification.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Next, we’ll learn how to create subscribers on Novu - *Recipients of Notifications*

# Create A Subscriber

Click **Subscribers** on the left sidebar of the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-quick-vue) to see all subscribers. By default, the dashboard will display a subscriber, as you were added automatically during sign-up.

<Frame>
  <img />
</Frame>

Now, let's create a subscriber on Novu.

Novu has a plethora of backend SDKs (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin) to choose from to create a subscriber programmatically. This is the recommended method.

Obtain your API key from your [Novu dashboard.](https://web.novu.co/settings?utm_campaign=docs-quick-vue) Replace `<NOVU_API_KEY>` with it.

Now check your Novu dashboard. You should see the recently created subscriber.

You can also update the subscriber info like so:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

await novu.subscribers.update('132', {
  email: 'janedoe@domain.com', // new email
  phone: '+19874567832', // new phone
});
```

# Trigger A Notification

To trigger a notification, simply run the codesandbox below with the correct credentials.

```jsx theme={null}
// code to trigger a notification
```

`onboarding-in-app` is the workflow identifier we created earlier.

Ensure the `subscriberId` value in the backend code that triggers the notification matches the `subscriberId` in your **NotificationCenterComponent** code.

```tsx theme={null}
<template>
    <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>

<script lang="ts" setup>
    const subscriberId = '132'
    const applicationIdentifier = import.meta.env.NOVU_APP_IDENTIFIER
    const sessionLoaded = () => {
        console.log("Notification Center session loaded successfully!")
    }
</script>
```

Check your app again. You should see the recently triggered notification!

# Conclusion

Great job! If you've reached this point, you should now have successfully set up the notification center, created a subscriber, a workflow, configured a channel provider and triggered a notification in your Vue application.


# Preferences
Source: https://v0.x-docs.novu.co/subscribers/preferences



Novu provides a way to store user preferences in the subscribers data model.
This allows subscribers to specify and manage their preferences, without your intervention. Customizing preferences has become the standard expected behavior for people and Novu can take the technical burden of managing preferences off of you.

**Novu allows several levels of preferences:**

* Workflow level channel preferences
* Subscriber level channel preferences
* Global level channel preferences

## Workflow level channel preferences

When creating a new workflow on the Web platform, you can specify default preferences for the subscribers in channel settings. They will be used unless the subscriber overrides them by his own custom preference.

This will allow you to create sensible defaults but still provide the user with the ability to override them. Template level preference can be managed in channel settings. All channels are `ON` unless specified otherwise.

`Workflow Settings > Channels`

<img />

## Subscriber level channel preferences

Our notification center component will show a user the available preferences, user will be able to modify on the channel level. Critical workflows will be excluded from the list. Click on cog (setting) icon on notification center component to open subscriber channel preferences page.

<img />

<Note>
  Only channels with a matched step will be returned from the API in
  notification center preference page. In case no channel content was found, the
  API will return an empty array.
</Note>

## Global level channel preferences

<Info>Since v0.20.0</Info>

Subscribers can set global channel preferences, which override individual settings. For instance, if there are 10 workflows, and a subscriber wants to disable SMS notifications for all of them, they can do so with a single global preference.

### Get subscriber global preference

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.getGlobalPreference("subscriberId" );
    ```
  </Tab>
</Tabs>

[Get subscriber's global preference API](/api-reference/subscribers/get-subscriber-global-preferences)

### Update subscriber global preference

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    // enable in-app channel and disable email channel
    await novu.subscribers.updateGlobalPreference("subscriberId", {
      enabled: true,
      preferences: [{
        type: "in_app"
        enabled: true
      }, {
        type: "email"
        enabled: false
      }]
    });
    ```
  </Tab>
</Tabs>

[Update subscriber's global preference API](/api-reference/subscribers/update-subscriber-global-preference)

<Note>Global subscriber preference can be updated and accessed using API and SDK only. Currently we have not added support of global subscriber preference in UI.</Note>

## Exclude workflows from preferences (critical workflow)

In some cases, you don't want the subscriber to be able to unsubscribe from mandatory notifications such as Account Verification, Password Reset, etc...

In those cases you can turn off the toggle `Users will be able to manage subscriptions` in channel settings. Workflow will become `critical`, once this toggle is turned `OFF`. By default, every workflow is `non-critical` and subscribers can manage channel preferences irrespective of workflow-level channel preferences. Critical workflow will not show on the subscriber preferences page.

## Get subscriber preferences

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from "@novu/node";

    const novu = new Novu("<NOVU_API_KEY>");

    // 111 is subscriberId
    await novu.subscribers.getPreference("111");
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    // 111 is subscriberId
    $novu->getSubscriberPreferences('111')->toArray();
    ```
  </Tab>
</Tabs>

## Get subscriber preference by level

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu, PreferenceLevelEnum } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');
    // Get global level preference
    await novu.subscribers.getPreferenceByLevel("subscriberId", PreferenceLevelEnum.GLOBAL)

    // Get template level preference
    await novu.subscribers.getPreferenceByLevel("subscriberId", PreferenceLevelEnum.TEMPLATE);
    ```
  </Tab>
</Tabs>

## Update subscriber preference for a workflow

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu, ChannelTypeEnum } from "@novu/node";

    const novu = new Novu("<NOVU_API_KEY>");

    // enable in_app channel
    await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
      enabled: true,
      channel: { type: ChannelTypeEnum.IN_APP, enabled: true },
    });

    // enable email channel
    await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
      enabled: true,
      channel: { type: ChannelTypeEnum.EMAIL, enabled: true },
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    // enable in_app channel
    $novu->updateSubscriberPreference('subscriberId', 'workflowIdentfier', [
        'enabled' => true
        'channel' => [
          'type' => 'in_app',
          'enabled' => true
        ]
    ]);

    // enable email channel
    $novu->updateSubscriberPreference('subscriberId', 'workflowIdentfier', [
        'enabled' => true
        'channel' => [
          'type' => 'email',
          'enabled' => true
        ]
    ]);
    ```
  </Tab>
</Tabs>

## Order of priority of preferences

1. if `Users will be able to manage subscriptions` toggle is turned off i.e workflow is critical, this will override workflow level and subscriber level preferences and notification will always be sent.
2. if workflow is non critical and subscriber has `false` value set for `enabled` field in preference then all other channels will become inactive even if they have `true` state.
3. if workflow is non critical and subscriber has `true` value set for `enabled` field in preference then notification will be filtered based on subscriber channel preference.
4. Workflow level channel preferences will be applied to all subscribers by default unless subscriber overrides them.

`Example`

1. For `First Workflow`, `critical` is false, `enabled` is true, in\_app, email, push channels are true and sms, chat channels are false. As per above order of priority of preferences, notification will be filtered as per the subscriber preferences. The subscriber will receive in-app, email and push notifications, but not receive sms and chat notifications.

2. For `Second Workflow`, `critical` is false, `enabled` is false, all channels are true. As per above order of priority of preferences, subscriber will not receive any type of notification because all channels become disabled due to false value of `enabled` field.

3. For `Third Workflow`. `critical` is true, `enabled` is false, email, chat channels are false and the other three channels are true. As per above order of priority of preferences, subscriber will receive all type of notifications as this workflow is `critical`.

<Tabs>
  <Tab title="First Workflow">
    ```json theme={null}
    {
      "template": {
        "_id": "firstWorkflowIdentifier",
        "name": "First Workflow",
        "critical": false
      },
      "preference": {
        "enabled": true,
        "channels": {
          "in_app": true,
          "email": true,
          "sms": false,
          "push": true,
          "chat": false
        }
      }
    }
    ```
  </Tab>

  <Tab title="Second Workflow">
    ```json theme={null}
    {
      "template": {
        "_id": "secondWorkflowIdentifier",
        "name": "Second Workflow",
        "critical": false
      },
      "preference": {
        "enabled": false,
        "channels": {
          "in_app": true,
          "email": true,
          "sms": true,
          "push": true,
          "chat": true
        }
      }
    }
    ```
  </Tab>

  <Tab title="Third Workflow">
    ```json theme={null}
    {
      "template": {
        "_id": "thirdWorkflowIdentifier",
        "name": "Third Workflow",
        "critical": true
      },
      "preference": {
        "enabled": false,
        "channels": {
          "in_app": true,
          "email": false,
          "sms": true,
          "push": true,
          "chat": false
        }
      }
    }
    ```
  </Tab>
</Tabs>

## API

<CardGroup>
  <Card title="Get subscriber preferences API" icon="plug" href="/api-reference/subscribers/get-subscriber-preferences" />

  <Card title="Update subscriber preference for a workflow API" icon="plug" href="/api-reference/subscribers/update-subscriber-preference" />

  <Card title="Update workflow API" icon="plug" href="/api-reference/workflows/update-workflow" />
</CardGroup>

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="How to change enabled field from UI?">
    This field can only be changed using API.
  </Accordion>

  <Accordion title="What preferences are applied to a subscriber when we create a new workflow?">
    In the case of a new workflow, the subscriber will inherit all preferences
    from the workflow\.However, after subsequent preference updates, the
    subscriber's preferences will not inherit workflow-level preferences.
  </Accordion>

  <Accordion title="How to disable a workflow for a single subscriber?">
    You can turn off all workflow's channels for a subscriber using [subscriber preference](/subscribers/preferences#subscriber-level-channel-preferences). If all channels are off, then the subscriber will not receive any message from any channel step and hence workflow is disabled for that subscriber
  </Accordion>
</AccordionGroup>


# Subscribers
Source: https://v0.x-docs.novu.co/subscribers/subscribers



In Novu, we call the entities designed to receive notifications as `Subscribers`. Each subscriber is unique and identified by a unique subscriberId.

<Note>
  `subscriberId` is a unique identifier used by Novu to keep track of a specific subscriber.
  We recommend using the internal unique id your application uses for a specific user.
</Note>

Each subscriber has the following data points:

* **User Data** - Data stored in the subscriber object that you can easily access in your notification templates. This contains basic info such as first name, last name, avatar, locale, email, and phone. This data is fixed and structured.
* **Custom Data** - Apart from the above fixed structured user data, any unstructured custom data such as user's address, nationality, height, etc can also be stored in the `data` field using key-value pairs.
* **Channel Specific Credentials** - `deviceTokens` required to send push notifications and `webhookUrl` for chat channel providers can also be stored.

## Subscriber attributes

| Field        | Type   | Required | Example                                                                        |
| :----------- | :----- | :------- | :----------------------------------------------------------------------------- |
| subscriberId | string | true     | b0bea066-f5fe-11ed-b67e-0242ac120002                                           |
| firstName    | string | false    | John                                                                           |
| lastName     | string | false    | Doe                                                                            |
| email        | string | false    | [john.doe@domain.org](mailto:john.doe@domain.org).                             |
| phone        | string | false    | +13603963366                                                                   |
| locale       | string | false    | en                                                                             |
| avatar       | string | false    | [https://example.com/images/avatar.jpg](https://example.com/images/avatar.jpg) |
| data         | object | false    | `{"key": "value"}`                                                             |

## Subscriber response schema

**Novu subscriber object**

```json theme={null}
{
  "_id": "NOVU_GENERATED_SUBSCRIBER_ID",
  "_organizationId": "NOVU_GENERATED_ORG_ID",
  "_environmentId": "NOVU_GENERATED_ENV_ID",
  "firstName": "John",
  "lastName": "Doe",
  "subscriberId": "subscriberId",
  "email": "[john.doe@org.com](mailto:john.doe@org.com)",
  "phone": "+98712345670"
  "data": {
    "custome_key_1" : "custom_value_1",
    "custome_key_2" : "custom_value_2"
  }
  "channels": [
  {
    "credentials": {
      "deviceTokens": [
        "token1",
        "token2"
      ]
    },
    "_integrationId": "NOVU_GENERATED_INTEGRATION_ID",
    "providerId": "fcm"
  },
  {
    "credentials": {
      "webhookUrl": "URL"
    },
    "_integrationId": "NOVU_GENERATED_INTEGRATION_ID",
    "providerId": "discord"
  }
  ],
  "deleted": false,
  "createdAt": "2022-10-13T17:40:53.231Z",
  "updatedAt": "2022-10-13T17:41:53.238Z",
  "__v": 0,
  "isOnline": false,
  "lastOnlineAt": "2022-10-13T17:41:53.238Z",
  "avatar": "AVATAR_URL",
  "id": "NOVU_GENERATED_SUBSCRIBER_ID"
}
```

## Create a subscriber

You can create a subscriber in Novu using the `identify` method provided in Novu's SDK.

<Tip>The `identify` method serves the purpose of handling existing "subscriberId" providers within the database.
When a provider with the same subscriberId already exists, this method performs an update operation using the data present in the payload.
In cases where there is no pre-existing entry, the method generates a new one, thus exhibiting an <Tooltip>upsert</Tooltip>
behavior.</Tip>

<Note>
  It is possible for two subscribers to have the same email address in our system. This is because the `subscriberId` is the unique identifier that distinguishes one subscriber from another.
</Note>

```jsx theme={null}
import { Novu } from "@novu/node";

// Insert your Novu API Key here
const novu = new Novu("<NOVU_API_KEY>");

// Create a subscriber on Novu
await novu.subscribers.identify("132", {
  email: "john.doe@domain.com",
  firstName: "John",
  lastName: "Doe",
  phone: "+13603963366",
});
```

<Warning> The `phone` parameter must be parsed as a string.</Warning>

You should now be able to see your new subscriber on the Novu dashboard.

You can also add additional fields such as `phone`, `avatar`, and `data`.

<Note> Remember, all user IDs added to Novu need to be unique. </Note>

If you face issues with the subscriber creation only taking the user ID and omitting other fields such as firstName, lastName, etc., you could consider updating the subscriber after creation.

Please also be aware that although it's currently possible to create a subscriber with an empty `subscriberId`, this subscriber cannot be deleted later.

We support creating new subscriber using two ways, `Ahead of Trigger` means adding subscribers before triggering notification or `Inline of Trigger` means sending complete subscriber data in `to` field while triggering.

### 1. Ahead of Trigger

Create the subscriber and then trigger the notification to this subscriber. Here `subscriberId` is the required field and other fields are optional.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.identify('111', {
      email: 'john.doe@domain.com',
      firstName: 'John',
      lastName: 'Doe',
      phone: '+13603963366',
      avatar: 'https://example.com/images/avatar.jpg',
      locale: 'en-US',
      data: { customKey1: 'customVal1', customKey2: 'customVal2' },
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->createSubscriber([
        'subscriberId' => '111',
        'email' => 'john.doe@domain.com',
        'firstName' => 'John',
        'lastName' => 'Doe',
        'phone' => '+13603963366',
        'avatar' => 'https://example.com/images/avatar.jpg',
        'locale' => 'en',
        'data' => [
          'customKey1' => 'customVal1',
          'customKey2' => 'customVal2'
        ]
    ]);
    ```
  </Tab>
</Tabs>

Novu will create a subscriber if one does not exist and will update the existing subscriber based on the `identify` payload. You can call this function during registration or signup to make sure the subscriber data is up-to-date, if you wish to save additional attributes with a subscriber, you can pass additional custom data in the **data** field as key-value pairs.

### 2. Inline of Trigger

A non-existing subscriber can be added by sending subscriber data in `to` field of the trigger method. If any subscriber with provided `subscriberId` does not exists, a new subscriber will be created. In this case, subscriber will be created first and then the trigger will be executed synchronously.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '111',
        email: 'john.doe@domain.com',
        firstName: 'John',
        lastName: 'Doe',
        phone: '+13603963366',
      },
      payload: {
        customVariable: 'variableValue',
        organization: {
          logo: 'https://organization.com/logo.png',
        },
      },
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->triggerEvent([
      'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
      'to' => [
          'subscriberId' => '111',
          'email' => 'john.doe@domain.com',
          'firstName' => 'John',
          'lastName'  => 'Doe',
          'phone' => '+13603963366'
      ]
      'payload' => [
          'customVariable' => 'variableValue',
          'organization' => [
            'logo' => 'https://organization.com/logo.png',
          ]
        ],
    ]);
    ```
  </Tab>
</Tabs>

## Bulk Subscriber Creation

You can create subscribers in bulk *(up to 500 at once)* via the SDKs or [API](/api-reference/subscribers/bulk-create-subscribers).

<Note> The bulk subscriber creation feature is only available in v0.19.0 and above.</Note>

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    await novu.subscribers.bulkCreate([
      {
        subscriberId: 'test-subscriber-1',
        email: 'test-user@sd.com',
        firstName: 'subscriber-1',
        lastName: 'test-1',
      },
      {
        subscriberId: 'test-subscriber-2',
        email: 'test-user-2@sd.com',
        firstName: 'subscriber-2',
        lastName: 'test-2',
      },
      {
        subscriberId: 'test-subscriber-3',
      },
    ]);
    ```
  </Tab>
</Tabs>

## Import subscribers

Here, `mock_data.csv` file is a CSV file having mock data. The below script will read this CSV file and create a new subscriber in Novu. Change example variables values like `API_KEY` value with your valid values. Download `mock_data.csv` file from [here](https://drive.google.com/file/d/159Upw30ZcPa_QnzlKF-C6_dHKDJeU-TW/view).

<Note> `mock_data.csv` file should be in the same directory of script </Note>

Steps:

1. Export your user details in CSV format.
2. Clean this exported CSV file. Keep only relevant fields.
3. Move this CSV file to the script directory.
4. Change the file name in the script with your file name.
5. Run the script. (Make script.sh executable before using)

<Tabs>
  <Tab title="Shell">
    ```shell theme={null}
    #!/bin/bash

    # Change these variables with your own values
    CSV_FILE="mock_data.csv"
    API_ENDPOINT="https://api.novu.co/v1/subscribers"
    API_KEY="ApiKey <API_KEY>"

    OLDIFS=$IFS
    IFS=','
    [ ! -f $CSV_FILE ] && { echo "$CSV_FILE file not found"; exit 99; }

    SECONDS=0

    # Read the CSV file line by line
    while read subscriberId firstName lastName email phone locale avatar
    do
        # Check if subscriberId is empty or not present
        if [[ -z "$subscriberId" ]]; then
            echo "Skipping row with missing subscriberId"
            continue
        fi

        # Construct the JSON body for the POST request
        json_body="{\"subscriberId\": \"$subscriberId\""

        # Add optional fields to the JSON body if present
        if [[ -n "$firstName" ]]; then
            json_body="$json_body, \"firstName\": \"$firstName\""
        fi

        if [[ -n "$lastName" ]]; then
            json_body="$json_body, \"lastName\": \"$lastName\""
        fi

        if [[ -n "$email" ]]; then
            # Validate email using regex
            if [[ ! "$email" =~ ^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$ ]]; then
                echo "Invalid email format for subscriberId: $subscriberId"
                continue
            fi
            json_body="$json_body, \"email\": \"$email\""
        fi

        if [[ -n "$phone" ]]; then
            json_body="$json_body, \"phone\": \"$phone\""
        fi

        if [[ -n "$locale" ]]; then
            # Validate locale using regex
            if [[ ! "$locale" =~ ^[a-zA-Z]{2}(-[a-zA-Z]{2})?$ ]]; then
                echo "Invalid locale format for subscriberId: $subscriberId"
                continue
            fi
            json_body="$json_body, \"locale\": \"$locale\""
        fi

        if [[ -n "$avatar" ]]; then
            json_body="$json_body, \"avatar\": \"$avatar\""
        fi

        if [[ -n "$address" || -n "$job" ]]; then
            json_body="$json_body, \"data\": {"

            if [[ -n "$address" ]]; then
                json_body="$json_body \"address\": \"$address\""
            else
                json_body="$json_body \"address\": \"\""
            fi

            if [[ -n "$job" ]]; then
                json_body="$json_body, \"job\": \"$job\""
            else
                json_body="$json_body, \"job\": \"\""
            fi

            json_body="$json_body }"
        fi

        json_body="$json_body}"

        echo $json_body

        #Send the cURL POST request with the JSON body and handle exceptions
        response=$(curl -s -X POST -H "Content-Type: application/json" -H "Authorization: $API_KEY" -d "$json_body" -w "%{http_code}" "$API_ENDPOINT")

        http_code=${response:${#response}-3}

        if [[ $http_code -eq 201 ]]; then
            echo "cURL request successful for subscriberId: $subscriberId - HTTP Status Code: $http_code"
        else
            echo "cURL request failed for subscriberId: $subscriberId - HTTP Status Code: $http_code - response : $response"
        fi

    done < "$CSV_FILE"

    ELAPSED="Time Elapsed: $(($SECONDS / 3600))hrs $((($SECONDS / 60) % 60))min $(($SECONDS % 60))sec"

    echo $ELAPSED
    ```
  </Tab>

  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';
    require('dotenv').config();

    const csv = require('csv-parser');
    const fs = require('fs');

    const novu = new Novu('<NOVU_API_KEY>');

    fs.createReadStream('mock_data.csv')
      .pipe(csv())
      .on('data', async (data) => {
        let subscriber = await novu.subscribers.identify(data.subscriberId, {
          email: data.email,
          firstName: data.firstName,
          lastName: data.lastName,
          phone: data.phone,
          avatar: data.avatar,
          locale: data.locale,
          data: { address: data.address, job: data.job },
        });

        console.log(subscriber.data);
      })
      .on('end', () => {
        console.log('done');
      });
    ```
  </Tab>
</Tabs>

## Delete a subscriber

To stop a subscriber from receiving notifications, you can delete the subscriber. This will hard delete the subscriber and means you will not be able to access this subscriber later. You will have to create this subscriber again.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.delete('111');
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->deleteSubscriber('111');
    ```
  </Tab>
</Tabs>

## Update a subscriber

In some cases, you want to access a subscriber to update a specific user data field or custom data field. For example, when the users change their email address or personal details.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.update('111', {
      // new email
      email: 'john@domain.com',
      // new phone
      phone: '+19874567832',
    });
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->updateSubscriber('111', [
        // new email
        'email' => 'john@domain.com',
        // new phone
        'phone' => '+19874567832',
    ])->toArray();
    ```
  </Tab>
</Tabs>

## Find a subscriber

Any subscriber can be retrieved using a unique subscriber identifier `subscriberId`. Check the returned subscriber schema [here](#subscriber-response-schema).

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.get('111');
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use Novu\SDK\Novu;

    $novu = new Novu('<NOVU_API_KEY>');

    $novu->getSubscriber('111')->toArray();
    ```
  </Tab>
</Tabs>


# Topics
Source: https://v0.x-docs.novu.co/subscribers/topics



Novu offers a simple API providing an easy interface for triggering notifications to multiple subscribers at once. It is called Topics and allows the users to manage their bulk notifications without having to do complex loop implementations. A topic is identified by a custom key that is provided by the user. This custom key will be the identifier for the topic.

<Warning>
  The topic key should be unique and can't be changed once chosen. Novu also safe guards for key uniqueness behind the scenes.
</Warning>

Users can also assign a name to a topic. This name doesn't need to be unique and it can be changed using the API. So far, it is for descriptive goals.

A topic would get assigned different subscribers that will receive a notification every time a notification is sent to the topic.

## Create A Topic

In order to be able to send a notification to a topic, first the user needs to create one. It can be done like this:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const result = await novu.topics.create({
  key: 'unique-topic-identifier',
  name: 'descriptive-topic-name',
});
```

If successful this will return the internal Id generated by Novu and the topic key given by the user.

That topic key can be used to retrieve the whole Topic entity:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const key = 'unique-topic-identifier';

const result = await novu.topics.get(key);
```

## Rename a Topic

Descriptive name given during creation of topic can be changed later. This can be done like this:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const topicKey = 'posts:comment:12345';
const topicName = 'Post Comments';

const result = await novu.topics.rename(topicKey, topicName);
```

This will return the whole Topic information, including the subscribers if having any.

<Note>Topic Key can not be changed</Note>

## Add subscribers to a Topic

Adding subscribers to the topic is the main usecase of topic. A topic is like a group of subscribers. A notification can be sent to all subscribers of a topic at once

<Warning>
  Before adding subscribers to a topic, it's crucial to ensure that they are correctly identified in the Novu system. This identification is done using the [identify method](/subscribers/subscribers#create-a-subscriber) or API. When a subscriber is added to a topic, Novu uses the identification information to pick up the email or phone number associated with the subscriber.
</Warning>

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const topicKey = 'posts:comment:12345';

const response = await novu.topics.addSubscribers(topicKey, {
  subscribers: ['subscriber-id-1', 'subscriber-id-2', ...],
});
```

This call will return a response in the shape of:

```typescript theme={null}
{
    succeeded: ['subscriber-id-1', 'subscriber-id-2', ...],
    failed: {
      notFound: ['subscriber-id-1', 'subscriber-id-2', ...],
    },
}
```

The field `succeeded` will return the array of subscriber ids that have been correctly assigned to the topic. The field `failed` will show up only if there has been any subscriber that couldn't been assigned to the topic. This probably will happen if there is any typo in the given subscriberId or if the given subscriberId doesn't belong to the environment and the organization where the topic has been created.

### Create topic on the fly

To facilitate flows we allow to create a topic on the fly when adding subscribers.

If the topic key used does not exist for the selected environment and organization, Novu will create a new topic with name `Autogenerated-<TOPIC_KEY>` and the subscribers will be assigned to this newly created topic.

After that, that topic created on the fly can be managed in the same ways as the ones created in the normal way.

## Verify if subscriberId belongs to a topic

There would be times when it would be needed to verify if a certain subscriber belongs to a topic in order to decide what to do with that subscriber. The API call to achieve that is the following:

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const externalSubscriberId = 'external-subscriber-id-1';
const topicKey = 'posts:comment:12345';

const response = await novu.topics.getSubscriber(topicKey, externalSubscriberId);
```

<Note>
  The subscriberId to use in this API call is the one used as subscriber identifier.
  The choice was made to make easier for the user to use this without making extra calls to Novu.
</Note>

## Remove a subscriber from a Topic

A single or group of subscribers can be removed from an existing topic.

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const topicKey = 'posts:comment:12345';

const response = await novu.topics.removeSubscribers(topicKey, {
  subscribers: ['subscriber-id-1', 'subscriber-id-2', ...],
});
```

Where `subscribers` will be an array of the subscriberIds we want to remove from the topic. If successful an empty response will be returned.

## Delete a topic

An existing topic can be deleted using topic-key as topic-key is the unique identifier for a topic.

```typescript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

const key = 'unique-topic-identifier';

const result = await novu.topics.delete(key);
```

<Warning>
  A topic can only be deleted if it doesn't have any subscriber added. When trying to delete a topic with subscribers a conflict error will be returned. This is done to prevent accidental topic deletions.
</Warning>

## Trigger workflow to a topic

A workflow can be triggered to a single subscriber and an array of subscribers. While doing so, one need to send subscriberIds in `to` field. In case of trigger, we have already stored subscriberIds in a topic, so a topic key can be used to trigger a workflow. Workflow will be triggered to all subscribers in the topic.

```typescript theme={null}
const topicKey = 'posts:comment:12345';

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: [{ type: 'Topic', topicKey: topicKey }],
  payload: {},
});
```

## Trigger workflow to multiple topics

Workflow can be triggered to multiple subscribers by using an array of topics.

```typescript theme={null}
const topicKey = '<TOPIC-KEY-DEFINED-BY-THE-USER>';

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: [
    { type: 'Topic', topicKey: topicKey },
    { type: 'Topic', topicKey: 'Another Topic Key' },
  ],
  payload: {},
});
```

## Exclude actor from topic trigger event

To exclude the actor responsible for the action of a triggered topic event, you must add the subscriberId of that actor when triggering that event.

```typescript theme={null}
const topicKey = 'posts:comment:12345';

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: [{ type: 'Topic', topicKey: topicKey }],
  payload: {},
  actor: { subscriberId: '<SUBSCRIBER_ID_OF_ACTOR>' },
});
```

## Usecase Example

User X makes a comment, other users (A, B) who've already commented before should get a notification. So, when triggering the notification on that topic, you would usually want to exclude User X from receiving a notification about their own comment. To do that - you would need to add User X's subscriberId to the trigger event.

## API

<CardGroup>
  <Card title="Fetch list of topics" icon="plug" href="/api-reference/topics/filter-topics" />

  <Card title="Create a new topic" icon="plug" href="/api-reference/topics/topic-creation" />

  <Card title="Add subscribers to a topic" icon="plug" href="/api-reference/topics/subscribers-addition" />

  <Card title="Check if subscriber belongs to a topic" icon="plug" href="/api-reference/topics/check-topic-subscriber" />

  <Card title="Remove subscribers from a topic" icon="plug" href="/api-reference/topics/subscribers-removal" />

  <Card title="Fetch a topic by topic-key" icon="plug" href="/api-reference/topics/get-topic" />

  <Card title="Delete a topic" icon="plug" href="/api-reference/topics/delete-topic" />

  <Card title="Rename a topic" icon="plug" href=" /api-reference/topics/rename-a-topic" />
</CardGroup>

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="Does it mean that all subscribers of one topic have same preference">
    No, adding subscribers into topic does not change subscriber's individual [subscriber preference](/subscribers/preferences). Topic is mainly used to group subscribers and fan out workflow triggered notifications to all subscribers at once.
  </Accordion>
</AccordionGroup>


# Activity Feed
Source: https://v0.x-docs.novu.co/activity-feed/introduction

Monitor all your activity from one place

## Introduction

Novu provides a notification activity feed that monitors every outgoing message associated with its relevant metadata. This can be used to monitor activity and discover potential issues with a specific provider or channel type.

<Frame>
  <img />
</Frame>

## Viewing a specific subscriber's activity

To use a subscriber's activity feed you can filter the feed by using the subscriberId or email. This will show only the relevant data for this particular subscriber.

To do this, just enter the `subscriberId` or the 'email' of the subscriber you want to get info of and then click the 'search' button on the right-hand side as shown in the image below:

<Frame>
  <img />
</Frame>

## Filter by workflow or channel

The activity feed allows you to filter messages based on the associated workflow or channel. This is helpful when you want to assess or debug a particular workflow and its behaviour.

Filtering by workflow or channel is quite simple. Just go to the Workflow dropdown (if you want to filter by workflow) or the channel tab (if you want to filter by channel) and select the corresponding workflow or channel and click the 'search' button on the right-hand side as shown in the image below:

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Troubleshooting with the activity feed

The activity feed also shows if a transaction is failing. You can see why a transaction is failing and rectify it. For example, take a look at the following image:

<Frame>
  <img />
</Frame>

You can see that an SMS notification has failed to get delivered. Clicking on it opens the execution details and the reason why that transaction failed

<Frame>
  <img />
</Frame>

This can help troubleshoot the problem and comes in handy at the time of distress.

## Digest info in the activity feed

If you’re using our digest notifications functionality, you’ll be able to see all the digest-related information in the activity feed.

<Frame>
  <img />
</Frame>

Some of the information related to digest present in the activity feed is:

* Digest step delay
* Digesting start time
* Digest triggered events details
* More digest execution details

<Frame>
  <img />
</Frame>

From here, you can see the details of ‘digest triggered events’ to see exactly which events were digested and the content of the notification you sent, as shown below:

<Frame>
  <img />
</Frame>

## Trigger Event Lifecycle

### **Trigger request**

The request contains details such as the identifier for the template, the list of subscribers who will receive the notification, the payload of the notification, and any overrides that need to be applied.

### Trigger endpoint

After the request is sent to the `/event/trigger` endpoint, the initial step involves mapping and validating the subscribers for that event. Following that, we validate the template and steps based on the active status or draft template flag.

Once the validation process is complete, the attachments are uploaded to the storage service.

Next, the trigger event with mapped subscribers and attachment links is appended to the **trigger event queue**. By queuing the events, we can achieve faster response times.

### **Trigger event processing**

When the event is picked up by the **trigger queue worker** we process it. For every subscriber listed in the trigger event, we create a notification entity and the corresponding jobs based on the notification template steps. The notification contains data related to the organization, template, subscriber, and event payload. It is updated with a channels field that is generated from the steps.

### **Jobs**

Every job is created according to the steps outlined in the template. If the template contains a digest step, the **filtering logic** is applied to produce the appropriate jobs array depending on the type of digesting: **regular** or **backoff**.


# Trigger Event Lifecycle
Source: https://v0.x-docs.novu.co/activity-feed/trigger-event-lifecycle

Managing Trigger Events from Request to Processing

## Trigger Request

A trigger request is the initial step in handling a trigger event. It contains crucial details such as the template identifier, a list of subscribers who will receive the notification, the payload of the notification, and any overrides that need to be applied.

## Trigger Endpoint

Upon sending the request to the `/event/trigger` endpoint, a series of essential steps are initiated:

1. **Subscriber Mapping and Validation:** The first step involves mapping and validating the subscribers for the specified event. This ensures that notifications are sent to the correct recipients.

2. **Template Validation:** Following subscriber validation, the template associated with the event is validated. This validation process considers factors such as the active status or draft template flag to determine if it meets the necessary criteria for processing.

3. **Attachment Upload:** Once the validation process is successfully completed, any attachments associated with the event are uploaded to the designated storage service.

4. **Event Queuing:** The trigger event, now enriched with mapped subscribers and attachment links, is appended to the **trigger event queue**. This queuing mechanism optimizes response times, ensuring efficient event processing.

## Trigger Event Processing

When an event is picked up by the **trigger queue worker**, the processing phase begins. Here's what happens:

* **Notification Entity Creation:** For each subscriber listed in the trigger event, a corresponding notification entity is created. This entity contains essential data related to the organization, template, subscriber, and event payload.

* **Job Creation:** Based on the notification template's defined steps, jobs are generated. These jobs are responsible for carrying out specific tasks related to the event notification. Additionally, the notification entity is updated with a "channels" field generated from these steps, indicating the communication channels through which notifications will be sent.

## Jobs

Jobs play a pivotal role in the trigger event lifecycle. They are created based on the steps outlined in the notification template. Depending on the presence of a digest step, the following logic is applied:

* **Digest Step:** If the template includes a digest step, filtering logic is applied to produce an appropriate array of jobs. This logic differentiates between two types of digesting: **regular** and **backoff**, each serving distinct purposes in event processing.

## Job Statuses

| Status        | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **PENDING**   | This status is assigned to a job before it is added to the worker queue. It indicates that the job is waiting to be processed.                                                                                                                                                                                                                                                                                                                                                                                                                       |
| **QUEUED**    | After the initial validation and just before adding a job to the worker queue, it is set to `QUEUED`. This status signifies that the job is ready for processing but is awaiting its turn in the queue.                                                                                                                                                                                                                                                                                                                                              |
| **RUNNING**   | When a job is picked up by a worker from the queue, its status is changed to `RUNNING`. This indicates that the job is currently being processed by a worker.                                                                                                                                                                                                                                                                                                                                                                                        |
| **COMPLETED** | Once a job has been successfully executed and processed, its status is changed to `COMPLETED`. This signifies that the job has been successfully completed.                                                                                                                                                                                                                                                                                                                                                                                          |
| **FAILED**    | If a job encounters an issue during processing or execution, its status is changed to `FAILED`. This indicates that the job has not been successfully completed, and there may have been errors or problems during processing.                                                                                                                                                                                                                                                                                                                       |
| **DELAYED**   | The `DELAYED` status is applied to specific types of jobs, such as `digest` or `delay` jobs, to indicate that they are delayed and not immediately processed. For `digest` jobs, it means that the digesting process is running or scheduled for a later time. For `delay` jobs, it signifies that the job is set to be executed at a specified delay time.                                                                                                                                                                                          |
| **CANCELED**  | When a job is canceled for any reason, its status is set to `CANCELED`. This indicates that the job will not be processed further and is effectively removed from the processing queue.                                                                                                                                                                                                                                                                                                                                                              |
| **MERGED**    | The `MERGED` status is assigned to events that are part of a `digest`. It indicates that an event will be merged into the digesting event. In a digesting process, there is typically a primary or initial event that serves as the digesting event, and subsequent events are merged into it. Instead of having a separate `COMPLETED` status for these merged events, they are marked as `MERGED` to indicate their specific role in the digesting process.                                                                                        |
| **SKIPPED**   | The `SKIPPED` status is used in the context of backoff versions of digesting. In this scenario, the first event's digesting is skipped, and the second event takes on the digesting role. The `SKIPPED` status is applied to the first event's digesting, indicating that it was intentionally skipped in the digesting process. Subsequent events may be merged into the second event's digesting process, as explained with the `MERGED` status. The `SKIPPED` status helps differentiate the skipped event from others in the digesting sequence. |

**Example:**

<Frame>
  <img />
</Frame>

<Steps>
  <Step title="Step created">
    `PENDING`
  </Step>

  <Step title="Step queued">
    `QUEUED`
  </Step>

  <Step title="Start sending message">
    `RUNNING`
  </Step>

  <Step title="Message created">
    `RUNNING`
  </Step>

  <Step title="Message sent">
    `COMPLETED`
  </Step>
</Steps>


# Discord
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/discord

Learn about how to use Discord provider for chat notifications

When using Discord, you will have to store the integration credentials within the subscriber entity. Discord supports two ways to do this:

1. Using the **Discord Webhook** integration.
2. Using the **Discord Bot** integration.

Right now, Novu only supports the **Discord Webhook** integration. This approach has been because the easiest way to set it up is when you have a predefined destination for where the notifications should be sent. It's particularly useful for notifying a specific channel about updates.

**Quickstart:**

To get started with using Novu’s Discord Webhook integration, you need a ‘webhook token’. Here’s how you can generate the same for testing purposes:

1. Go to the channel you want to add the webhook to (you need to be an admin of the discord server).
2. Right-click the channel and select "Edit Channel".
3. Integrations -> Webhooks -> New Webhook
4. Copy the webhook URL.
5. After obtaining the webhook URL in the previous step, you need to store it within the subscriber entity. Doing this ensures that Novu knows where (in which discord channel) to send the notification to. Here’s how to do it:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Discord, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "discord",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "discord-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum to specify the provider.
* The third parameter is the credentials object. In this case, we use the `webhookUrl` property to specify the webhook URL generated in the previous step.

6. You are all set up and ready to send your first chat message via our `@novu/node` package or directly using the REST API in the channel you chose on your discord server.


# MS Teams
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/ms-teams

Learn about how to use MS Teams provider for chat notifications

MS Teams does not need any `API Key` or `Client ID` to send notifications. Our current implementation is based on the [Incoming Webhook URL](https://learn.microsoft.com/en-us/microsoftteams/platform/webhooks-and-connectors/how-to/add-incoming-webhook?tabs=newteams%2Cjavascript). It is a URL that you can use to send messages to a specific channel. This URL needs to be stored on the subscriber entity

Similar to [Discord](https://www.notion.so/Additional-Resources-65ef4aca5d0f4115947030c2f5705101?pvs=21), the credential for this provider needs to be stored in the [subscriber entity](/api-reference/subscribers/update-subscriber-credentials).

## Creating incoming webhook URL

Checkout step by step instructions on microsoft team's documentation on how to [create an incoming webhook url](https://docs.microsoft.com/en-us/microsoftteams/platform/webhooks-and-connectors/how-to/add-incoming-webhook?tabs=newteams%2Cjavascript).

<Frame>
  <img />
</Frame>

## Storing webhook url on subscriber entity

The URL generated above will be the target channel of a subscriber that you want to integrate with. To make this connection, you have to:

1. Copy the URL that you generated above
2. Update the subscriber credentials with this URL using the MS Teams provider id. You can do this step by using the `@novu/node` library, as shown below:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials(
      'subscriberId', 
      ChatProviderIdEnum.MsTeams, // providerId
      { webhookUrl: "<WEBHOOK_URL>" },
      'msteams-MnGLxp8uy' // integration identifier
    );
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "msteams",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "msteams-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum to specify the provider.
* The third parameter is the credentials object, in this case, we use the `webhookUrl` property to specify the MS Teams channel webhook URL or by calling the `Update Subscriber Credentials` endpoint on Novu API. Check endpoint details [here](https://docs.novu.co/api/update-subscriber-credentials/).

<Info>
  If you are looking to use  provider in different way or your usecase is not covered by this documentation, you can always reach out to our team at [support@novu.co](mailto:support@novu.co) or via [Discord](https://discord.novu.co)
</Info>


# Chat Channel Overview
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/overview

Learn the process of configuring and using chat providers with Novu

Novu can be used to deliver chat messages to your customers using a unified delivery API. You can easily integrate your favorite chat provider using the built-in integration store.

<iframe />

## Configuring chat providers

To configure a chat provider, you need to add a new integration to your Novu account. You can do this by navigating to the integration store and clicking on the **Add a provider** button and then select the chat provider you want to configure. You can find the [integration store](https://web.novu.co/integrations?utm_campaign=docs-chat-overview) in the left sidebar of the Novu dashboard.

Each chat provider requires defferent type of credentials. There are few providers which does not require any credentials example: `Discord`

## Sending chat message

Steps to send a chat message using Novu:-

1. Add a chat provider integration to your Novu account from the integration store. Enter credentials if required and save the integration. Follow corresponding provider documentation to get the required credentials.
2. Create a new subscriber

> Step 2 can be skipped if you already have a subscriber. You can use the `subscriberId` of an existing subscriber.

3. [Update](/channels-and-providers/chat/overview#update-credential-webhookurl) the subscriber credential `webhookUrl` for this provider and integration.

4. Create a new [worklow](/workflows/notification-workflows) or use an existing workflow. Add chat channel and [write content](/content-creation-design/notification-content-creation#chat) for the message.

5. Trigger this workflow to above `subscriberId` using trigger identifier

6. Check the chat provider if message is received. If not, check the logs in [activity feed](/activity-feed/introduction) for for any errors.

## Update credential webhookUrl

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Slack, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "slack",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "slack-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

<Info> Integration identifier is similar to Provider identifier but it is different than Provider Id. It is unique for each integration. You can find the `integrationIdentifier` in the integration store page.  </Info>

## Common errors

Common erros and reason of those errors while sending chat messages using Novu.

1. Subscriber does not have a configured channel.
   * if the subscriber does not have credentials set up for any of the chat provider.
2. Webhook URL for the chat channel is missing.
   * `webhookUrl` field is null, undefined or not set. Check using [get subscriber api](/api-reference/subscribers/get-subscriber).
3. Subscriber does not have an active integration.
   * if subscriber have credentials set but integration is either not active or deleted for this credential.

<Tip>
  <MissingProvider />
</Tip>


# Slack
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/slack

Learn about how to use Slack provider for chat notifications

When using Slack you will have to save the integration credentials in the subscriber entity.

This guide will walk you through the steps needed to obtain the `webhookUrl` that Novu requires to send chat messages to your customers.

We will provide the basic flow that the user needs to perform, to successfully send notifications via the Slack integration.

<Note>We've a [dedicated guide](/guides/slack-guide) on integrating Novu in a Slack app.</Note>

### Creating application

This step is optional, if you already have a Slack application you can reuse it.

1. Go to Slack's developer dashboard [https://api.slack.com/apps](https://api.slack.com/apps).
2. Create a new application.

### Integrating Novu with Slack

There are two ways to integrate Novu with Slack - Novu Managed (recommended) and manually managed. Let’s look at both of them in detail:

### 1. Novu Managed (Recommended)

If you use this approach, then Novu will manage the OAuth flow and store the credentials

1. Configure your Slack application as mentioned [below](#configuring-slack-application).
2. You need to make a network request to the `Shareable URL` to perform authentication.
3. You can find the `Shareable URL` in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integrations-slack)

<Frame>
  <img />
</Frame>

4. You can either add the `Add to Slack` button or use the `Shareable URL` directly, in the application you'll be using Novu in.
   <Info>The network request to the 'Shareable URL' will happen when the user clicks the 'Add to Slack' button.</Info>
5. This is to request permission for access (scope: incoming-webhook).
6. You can use the generated `Shareable URL` that is found under the Slack integration in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integrations-slack). The `Shareable URL` should have the following format:

```bash theme={null}
https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials/slack/oauth?environmentId=<ENVIRONMENT_ID>&integrationIdentifier=<PROVIDER_ID>.

```

* `SUBSCRIBER_ID` is a custom identifier used when identifying your users within the Novu platform.
* `ENVIRONMENT_ID` is a context of an environment you can locate your environment id in the setting in the [dashboard settings](https://web.novu.co/settings?utm_campaign=docs-integrations-slack).
* `PROVIDER_ID` (optional) is a unique identifier of the integration and is required when you have multiple slack integrations in Novu. You can locate your integration identifier in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integratons-slack). When not provided, the last created integration will be used.
  If you are using the `Add to Slack` button you have to provide the `Shareable URL` as the `redirect_uri` parameter like in this example. Make sure that the `Shareable URL` is URL encoded:

```html theme={null}
<a
  href="https://slack.com/oauth/v2/authorize?client_id=CLIENT_ID&scope=incoming-webhook&user_scope=&redirect_uri=https%3A%2F%2Fapi.novu.co%2Fv1%2Fsubscribers%2FSUBSCRIBER_ID%2Fcredentials%2Fslack%2Foauth%3FenvironmentId%3DENVIRONMENT_ID%26integrationIdentifier%3DINTEGRATION_IDENTIFIER"
  ><img
    alt="Add to Slack"
    height="40"
    width="139"
    src="https://platform.slack-edge.com/img/add_to_slack.png"
    srcset="
      https://platform.slack-edge.com/img/add_to_slack.png    1x,
      https://platform.slack-edge.com/img/add_to_slack@2x.png 2x
    "
/></a>
```

7. Either you use the 'add to Slack' button or use the `Shareable URL`, you should land here:

<Frame>
  <img />
</Frame>

8. Then you'll be redirected to the address you chose in the [Integration Store](https://web.novu.co/integrations?utm_campaign=docs-integrations-slack):

<Frame>
  <img />
</Frame>

<Info>You can use the URL of whichever page you want your users to land on, after successful execution</Info>
9\. That's it! Now you can trigger your workflow and send notifications:

<Frame>
  <img />
</Frame>

<Note>Don't forget to check out our [dedicated guide](/guides/slack-guide) on integrating Novu in a Slack app for more.</Note>

### 2. Manually managed

To use the manually managed option, you need to generate a `webhookUrl` and plug it into your backend.

1. Goto 'Incoming Webhooks' in your Slack app settings and turn it on.

<Frame>
  <img />
</Frame>

2. Click on the 'Add New Webhook to Workspace':

<Frame>
  <img />
</Frame>

3. Now, go ahead and select the channel in which you want to send notifications and click 'allow'.

<Frame>
  <img />
</Frame>

4. Then, copy the 'webhookUrl' from Slack.

<Frame>
  <img />
</Frame>

5. Now, you need to save the `webhookUrl` on the relevant subscriber entity in Novu. Here's an example to do the same using our Node SDK:

## Update credential webhookUrl

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Slack, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "slack",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "slack-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum.Slack if you’re using Node, else string of Slack to specify the provider.
* The third parameter is the credentials object. In this case, we use the `webhookUrl` property to specify the webhook URL generated in the previous step.

6. You are all set up and ready to send your first chat message via our @novu/node package or directly using the REST API.

## Configuring Slack application

1. Go to OAuth & Permissions on Slack's Developer Dashboard and add your REDIRECT\_URL in Redirect URLs.
   * If you use a manual Management solution, add the API endpoint you created in Step 1.
   * If you use the Novu Managed solution add `https://api.novu.co/v1/subscribers`.
2. Go to Incoming Webhooks from the left menu and Activate Incoming Webhooks.
3. Go to Manage Distribution and at the bottom of the page, tick Remove Hard Coded Information and Activate Public Distribution.

### Enabling HMAC Encryption

To enable Hash-Based Message Authentication Codes, you need to do the following steps:

1. Visit the integration store page and enable HMAC encryption under your chat provider.

2. The next step would be to generate an HMAC encrypted subscriberId on your backend:

   ```jsx theme={null}
   import { createHmac } from 'crypto';

   const hmacHash = createHmac('sha256', process.env.NOVU_API_KEY)
     .update(subscriberId)
     .digest('hex');

   ```

3. Add the newly created hash HMAC to the Sharable URL as a query.

This concludes the Slack provider guide.


# How to send WhatsApp Business notifications with Novu
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/whats-app

Learn about how to use WhatsApp for chat notifications

## Getting Started

To integrate WhatsApp Business with Novu, You will have to create a facebook developer app and obtain the necessary credentials.

### Step 1: Create a Facebook Developer App

Visit the [Facebook Developer Portal](https://developers.facebook.com/apps/) and create a new app.

Select "Other" for "What do you want your app to do?" and select "Business" for "Select an app type".

### Step 2: Setup WhatsApp Product

On the App Setup page, click on "Set Up" under the "WhatsApp" product. You will need to create or add a Facebook Business Account to your app.

### Step 3: Send a Sandbox Message

Copy the following pieces and paste them in the Novu WhatsApp Business integration settings:

* Temporary Access Token - Access API token Field
* Phone Number ID - Phone Number Identification Field

<Warning>
  It's important to note that the test credentials for whatsapp cannot be used in production and will expire in 24 hours.
  You will need to submit your app for review to obtain production credentials.
</Warning>

### Step 4: Add a Test Phone Number

You can add a test phone number to the sandbox by clicking on the "Add Phone Number" button.
This number can be used to test your integration with Novu before submitting for a review.

### Step 5: Send a test notification from Novu

You can now create a new Workflow with a "Chat" node, and add your content. Save your workflow, and click on "Trigger Notification" Button.

In the to field, specify the phone number you added in the sandbox, and click on "Send Notification".

```json theme={null}
{
  "subscriberId": "TEST_SUBSCRIBER_ID",
  "phone": "+11111111111"
}
```

and in the `overrides` field, add the following:

```json theme={null}
{
  "chat": {
    "template": {
      "name": "hello_world",
      "language": {
        "code": "en_US"
      }
    }
  }
}
```

<Info>
  For test credentials you can only used the built in Whats App Template.
</Info>

## Going to Production

### Register a Business Phone Number

To go live you will need to add a real business phone number and submit your app for review.
Follow the [Facebook Instructions](https://developers.facebook.com/docs/whatsapp/cloud-api/get-started/add-a-phone-number) on how to proceed.

### Generate a permanent access token

Follow the [Facebook Instructions](https://developers.facebook.com/docs/whatsapp/business-management-api/get-started/) on how to generate a permanent access token.
Depending on your use case.

### Create a WhatsApp Template

You will need to create a WhatsApp Template to send notifications to your customers. Create a template in the [Business Manager](https://business.facebook.com/wa/manage/message-templates) and submit it for review.
After your template is approved, you can use the `template_name` to send notifications to your customers.

To send a notification with a template, you will need to add the following to the `overrides` field:

```typescript theme={null}
novu.trigger('workflow-id', {
    to: {
        subscriberId: "SUBSCRIBER_ID",
        phone: "+11111111111"
    },
    payload: {},
    overrides: {
        chat: {
            template: {
                name: "template_name",
                language: {
                    code: "en_US"
                }
            }
        }
    }
})
```


# Zulip
Source: https://v0.x-docs.novu.co/channels-and-providers/chat/zulip

Learn about how to use Zulip provider for chat notifications

Zulip does not need any API Key or client ID to push messages in it. All it needs is the webhook URL of the channel you want to send messages to. That itself acts as the credential.

Similar to Discord, the credential for this provider needs to be stored in the subscriber entity.

## Getting a Zulip webhook URL

* Sign up or Login to your Zulip account.

* Click on the Settings icon in the top right corner of the screen, and then click "Personal settings" from the drop-down menu.

<Frame>
  <img />
</Frame>

* Click "Add a new bot" button in "Bots" tab.

<Frame>
  <img />
</Frame>

* Set bot type as "Incoming webhook".

<Frame>
  <img />
</Frame>

* Click the small link icon to generate webhook URL for provider. Set Integration as `Slack compatible webhook`, choose your channel and copy webhook URL.

<Frame>
  <img />
</Frame>

## Connecting our subscribers to Zulip

The URL generated above will be the target channel of a subscriber that you want to integrate with. To make this connection, you have to:

1. Copy the URL that you generated above

2. Update the subscriber credentials with this URL using the Zulip provider id. You can do this step by using the `@novu/node` library, as shown below:

## Update credential webhookUrl

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', ChatProviderIdEnum.Zulip, {
      webhookUrl: "<WEBHOOK_URL>",
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "zulip",
      "credentials": {
          "webhookUrl": "<WEBHOOK_URL>"
      },
      "integrationIdentifier": "zulip-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

* `subscriberId` is a custom identifier used when identifying your users within the Novu platform.
* `providerId` is a unique provider identifier. We recommend using our ChatProviderIdEnum to specify the provider.
* The third parameter is the credentials object, in this case, we use the `webhookUrl` property to specify the MS Teams channel webhook URL or by calling the `Update Subscriber Credentials` endpoint on Novu API. Check endpoint details [here](https://docs.novu.co/api/update-subscriber-credentials/).

3. You are all set up and ready to send your first chat message via our `@novu/node` package or directly using the REST API.


# Novu Providers
Source: https://v0.x-docs.novu.co/channels-and-providers/default-providers

Learn about the default Novu email and sms providers

## Novu Providers

To help you evaluate our services better, Novu provides an email and sms provider by default for every account. After signing up, you can go to the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-default-providers) on the Novu web dashboard to see this.

<Note>
  This feature is available only in Novu cloud. This feature will not work in community self
  hosted version and local environment.
</Note>

## Novu Email Provider

If you've a newly signed-up account on Novu, it will look like this:

<Frame>
  <img />
</Frame>

## Novu SMS Provider

And this is what the default Novu SMS provider looks like:

<Frame>
  <img />
</Frame>

<Info>
  The default email and sms providers are for evaluation purposes only and their use in production-grade apps is not recommended. You should switch to any of our [numerous other providers](/additional-resources/glossary#3-providers) for production apps. Also, there are two modes for default Novu providers - Development and Production.
</Info>

## Novu In-app Provider

In addition to email and sms, we also have in-app provider:

<Frame>
  <img />
</Frame>

It is the only provider for the in-app channel and it *can be used in production apps*. Unlike sms and email, it is not active by default and needs to be turned on separately. It can be scaled as per your need and it is a 'pay as you go' offering. You can check [this](https://novu.co/pricing/?utm_campaign=docs-default-providers) for more details.

## Limits of the Novu Providers

Following are the limits for our email and sms providers:

1. Email: 300 emails per organization per month
2. SMS: 20 messages per organization per month

To send more than these limits, you can configure a different provider for a specific channel. Read more about them [here](/channels-and-providers/integration-store).


# Amazon SES
Source: https://v0.x-docs.novu.co/channels-and-providers/email/amazon-ses

Learn how to use the Amazon SES provider to send email notifications using Novu

You can use the [Amazon SES](https://aws.amazon.com/ses/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Amazon SES provider in the email channel, you will need to create an SES account and add your credentials to the Amazon SES integration on the Novu platform.

## Setting up SES in AWS?

* Either use a root AWS account or create a new IAM account with appropriate permission policies.
  <Tip>Example policy rule `arn:aws:ses:<REGION>:<ACCOUNT>:identity/*`</Tip>
* Create a new access key and save generated `ACCESS_KEY_ID` and `ACCESS_SECRET_KEY` carefully
* Choose Amazon Simple Email Service.
* Create a new identity.
* Either choose domain or email.
* Verify your domain (by adding a few DNS records as mentioned in SES instructions) or email (AWS sends a verification email to your email).
* Verify the recipient email also by creating a new email identity type \[only in sandbox mode].
* Test if your SES is set up correctly using the test email feature.

## Creating an SES integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-integrations-ses) page on Novu.
* Click on Add a Provider.
* Select Amazon SES service.
* Enter previously saved `ACCESS_KEY_ID` and `ACCESS_SECRET_KEY`.
* Fill in the `From email address` field using the authenticated sender email id in the previous step.
* Enter `region` and `Sender name` also.

<Tip>Example region format:- `us-east-1`. By default Novu uses `us-east-1` region.</Tip>

* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Amazon SES in Novu.

## FAQs

<AccordionGroup>
  <Accordion title="Trigger from novu is successful but the subscriber is not receiving email.">
    Possible reasons:

    1. You have not verified the subscriber's email address in SES (if you are in a sandbox environment).
    2. Your daily sending limit has been reached (if you are in a sandbox environment).
    3. You have entered the wrong aws region in the integration form.
  </Accordion>
</AccordionGroup>


# Braze
Source: https://v0.x-docs.novu.co/channels-and-providers/email/braze

Learn how to use the Braze provider to send email notifications using Novu

You can use the [Braze](https://braze.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Braze provider in the email channel, you will need to create a [Braze account](https://braze.com/) and add your API key and other credentials to the Braze integration on the Novu platform.

# Generating an API Key

To generate a new API key in Braze, you can follow these steps:

* [Sign up](https://braze.com) or [Log in](https://braze.com) to your Braze account.
* Go to **Settings > API Keys**.
* Click **+ Create New API Key**.
* Give your new key a name for identification at a glance.
* Select the right permission you want to be associated with the new API key.

# Creating a Braze integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-braze) page on Novu.
* Click on `Add a Provider`.
* Locate **Braze** under the Email section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `API Key`.
* Enter the `Base URL`.
* Enter the `From email address`.
* Enter the `Sender name`.
* Click on the **Update** button.


# Custom SMTP
Source: https://v0.x-docs.novu.co/channels-and-providers/email/custom-smtp

Learn how to use the Custom SMTP provider to send email notifications using Novu

You can use a Custom SMTP provider like [Nodemailer](https://nodemailer.com/about/) to send transactional emails through your custom SMTP server to your customers using the Novu Platform with a single API.

# Getting Started

To use the Custom SMTP provider in the email channel, you will need to have your personal SMTP server configured and add `host`, `port`, `user`, and `password` to the Custom SMTP integration on the Novu platform.

You can also provide value **`true`** for the `secure` field if you want the connection to be secure, and if not, leave it empty.

### DKIM (DomainKeys Identified Mail)

DKIM options can be used in order to sign messages sent using Custom SMTP with DKIM keys.

Those options are:

* `DKIM Domain`
* `DKIM Private Key`
* `DKIM Key Selector`

# Creating a Custom SMTP integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-customsmtp) page on Novu.
* Click on Add a Provider.
* Select Custom SMTP service.
* Enter your SMTP credentials
  * `host`
  * `port`
  * `username`
  * `password`
  * `secure` (on demand)
  * And `DKIM` options if you want to sign messages with *DKIM*
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Custom SMTP in Novu.


# Infobip - email
Source: https://v0.x-docs.novu.co/channels-and-providers/email/infobip

Learn how to use the Infobip provider to send email notifications using Novu

You can use the [Infobip](https://www.infobip.com/developers/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Infobip provider in the email channel, you will need to create an Infobip account and add your API key and Base URL to the Infobip integration on the Novu platform.

# Generating an API Key

To generate a new API key in Infobip, you can follow these steps:

* [Sign up](https://www.infobip.com/signup) or [Log in](https://portal.infobip.com/login/) to your Infobip account.
* Navigate to the [Settings](https://portal.infobip.com/settings/accounts/api-keys) of your account and look for the API Keys section at the top of the settings page.

# Creating an Infobip integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-infobip) page on Novu.
* Click on Add a Provider.
* Select Infobip service.
* Enter your Infobip API Key.
* Enter your Base URL.
  * To see your base URL, log in to the account. Once logged in, on all pages, you should see your base URL in this format: `xxxxx.api.infobip.com`.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Infobip in Novu.


# Mailersend
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailersend

Learn how to use the MailerSend provider to send email notifications using Novu

[MailerSend](https://www.mailersend.com/) is an email delivery service that allows you to send emails from your application.

## Getting Started

To use the MailerSend provider in the email channel, you will need to create a MailerSend account and add your API key to the MailerSend integration on the Novu platform. To generate the API token go visit the [MailerSend API Tokens](https://www.mailersend.com/help/managing-api-tokens) page.

## Creating the MailerSend integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mailersend) page on Novu.
* Click on Add a Provider.
* Select MailerSend service.
* Enter the API key.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using MailerSend in Novu.

## Using MailerSend template

Novu has its own email editor for writing email template. If you want to use pre made template from MailerSend, you can use `customData` filed of email overrides to send template details. Make sure your `Api Key` has enough permission to read and process the template.

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import {
      Novu
    } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.trigger("workflowIdentifier", {
      to: "subscriberId",
      payload: {},
      overrides: {
        email: {
          customData: {
            // mailersend template templateId
            templateId: 'mailersend-template-id',
            // mailersend template variables
            personalization: [{
              email: 'recipient@email.com',
              data: {
                items: {
                  price: '',
                  product: '',
                  quantity: '',
                },
                order: {
                  date: '',
                  order_number: '',
                  billing_address: '',
                  customer_message: '',
                },
                store: {
                  name: '',
                },
                invoice: {
                  total: '',
                  subtotal: '',
                  pay_method: '',
                },
                customer: {
                  name: '',
                  email: '',
                  phone: '',
                },
              },
            }, ],
          },
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl --location 'https://api.novu.co/v1/events/trigger' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <NOVU_API_KEY>' \
    --data '{
        "name": "workflowIdentifier",
        "to":  ["subscriberId"],
        "payload": {},
        "overrides": {
            "email": {
                "customData": {
                    "templateId": "mailersend-template-id",
                    "personalization": [{
                        "email": "recipient@email.com",
                        "data": {
                            "items": {
                                "price": "",
                                "product": "",
                                "quantity": ""
                            },
                            "order": {
                                "date": "",
                                "order_number": "",
                                "billing_address": "",
                                "customer_message": ""
                            },
                            "store": {
                                "name": ""
                            },
                            "invoice": {
                                "total": "",
                                "subtotal": "",
                                "pay_method": ""
                            },
                            "customer": {
                                "name": "",
                                "email": "",
                                "phone": ""
                            }
                        }
                    }]
                }
            }
        }
    }'
    ```
  </Tab>
</Tabs>


# Mailgun
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailgun

Learn how to use the Mailgun provider to send email notifications using Novu

You can use the [Mailgun](https://mailgun.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Mailgun provider in the email channel, you will need to create a Mailgun account and add your API key and domain name to the Mailgun integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mailgun, you can follow these steps:

* [Sign up](https://signup.mailgun.com/new/signup) or [Log in](https://login.mailgun.com/login/) to your Mailgun account.
* Click on the **Profile** section in the top right corner of the screen, and then click "API Keys" from the drop-down menu.
* On the [API Keys](https://app.mailgun.com/app/account/security/api_keys) page, copy the generated **Private API Key**

# Adding a new domain name

Mailgun recommends that you add a subdomain as a domain name. To do so:

* Visit the page to add a [domain name](https://app.mailgun.com/app/sending/domains/new).
  * During this process, you will need to choose a region for the domain name which is between `US` and `EU`. The default is `US`.
* Follow the [instructions](https://documentation.mailgun.com/en/latest/user_manual.html#verifying-your-domain-1) to verify the domain name.

# Creating a Mailgun integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mailgun) page on Novu.
* Click on Add a Provider.
* Select Mailgun service.
* Enter your Mailgun API Key.
* Enter your Base URL.
  * For domains created in the EU region, the base URL is: `https://api.eu.mailgun.net/`
  * Otherwise, leave the base URL blank.
* Fill in the `Username`.
* Fill in the `Domain name` registered on Mailgun.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Mailgun in Novu.


# Mailjet
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailjet

Learn how to use the Mailjet provider to send email notifications using Novu

You can use the [Mailjet](https://mailjet.com/) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the Mailjet provider in the email channel, you will need to create a Mailjet account and add your API key to the Mailjet integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mailjet, you can follow these steps:

* Log in to your Mailjet account.
* Click on **Settings** in the top-right corner of the screen, and then click **API KEYS & TRACKING** from the drop-down menu.
* On the API Keys page, click the **Create an API Key** button.
* Give the API key a name and choose the access level **Write and Read**
* Click the **Generate Key** button to create the new key. Once generated you can see the key but it will be hidden after the refresh

# Authenticating your sender identity

Before you can send emails on a large scale, you will need to authenticate your Sender identity. This is due to the latest regulatory changes regarding SPAM rules and email fraud. Most of the providers including Mailjet require you to authenticate your Sender identity before you can send emails.

Mailjet allows you to authenticate your sender identity using one of the following methods:

* [Single Sender Verification](https://dev.mailjet.com/email/guides/senders-and-domains/#sender-validation) - This is the easiest way to authenticate your sender identity.
* [Entire Domain Authentication](https://dev.mailjet.com/email/guides/senders-and-domains/#spf-and-dkim-validation) - This is recommended if you are sending emails from multiple accounts under your domain.

# Creating a Mailjet integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mailjet) page on Novu.
* Click on Add a Provider.
* Select Mailjet service.
* Enter your Mailjet API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Mailjet in Novu.


# Mailtrap
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mailtrap

Learn how to use the Mailtrap provider to send email notifications using Novu

You can use the [Mailtrap](https://mailtrap.io/email-sending/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Mailtrap provider in the email channel, you will need to create a Mailtrap account and add your API key to the Mailtrap integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mailtrap, you can follow these steps:

* [Sign Up](https://mailtrap.io/register/signup) or [Log in](https://mailtrap.io/signin) to your Mailtrap account.
* Click on the **Email Sending** link on the sidebar, and then click the "Sending Domains" link that pops up from the available options.
* On the [Sending Domains](https://mailtrap.io/sending/domains) page, type your domain name and confirm with the `Add Your Domain` button. Then, proceed to copy DNS records Mailtrap provides to your domain’s DNS.
* Go to [API Keys](https://mailtrap.io/api-tokens) page and copy token with `Domain Admin` access level for your registered domain.

# Authenticating your Sender Identity

Before you can send emails, you will need to [verify your sending domain ownership](https://help.mailtrap.io/article/69-sending-domain-setup). Mailtrap rejects sending emails from unverified domains to prevent spam and email fraud.

# Creating a Mailtrap integration with Novu

* Visit the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-mailtrap) on the Novu web dashboard.
* Click on Add a Provider.
* Select Mailtrap service.
* Enter your Mailtrap API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications through Mailtrap using Novu.


# Mandrill
Source: https://v0.x-docs.novu.co/channels-and-providers/email/mandrill

Learn how to use the Mandrill provider to send email notifications using Novu

You can use the [Mandrill by Mailchimp](https://mandrillapp.com/) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the Mandrill provider in the email channel, you will need to create a Mandrill account and add your API key to the Mandrill integration on the Novu platform.

# Generating an API Key

To generate a new API key in Mandrill, you can follow these steps:

* [Sign up](https://login.mailchimp.com/signup/) or [Log in](https://login.mailchimp.com/) to your Mandrill account.
* Navigate to the [Settings](https://mandrillapp.com/settings) of your account and look for the API Keys section at the bottom of the settings page.
* Click on the **+ Add API Key** button to create an API key. Copy the generated key immediately and store it in a secure location. You won’t be able to see or copy the key once you finish generating it.

# Adding a sending domain

To get started, you’ll need to add the domain that you want to send messages from.

* Navigate to the [Settings page](https://mandrillapp.com/settings/sending-domains) and choose Domains
* Type a new domain in the domain input and click Add
* Follow the instructions to [verify ownership](https://mailchimp.com/developer/transactional/docs/authentication-delivery/#authentication) of your sending domain and [update your DNS records](https://mailchimp.com/developer/transactional/docs/authentication-delivery/#configure-your-dns).

# Creating the Mandrill integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-mandrill) page on Novu.
* Click on Add a Provider.
* Select Mandrill service.
* Enter your Mandrill API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Mandrill in Novu.


# Netcore
Source: https://v0.x-docs.novu.co/channels-and-providers/email/netcore

Learn how to use the Netcore provider to send email notifications using Novu

You can use the [Netcore](https://netcorecloud.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Netcore provider in the email channel, you will need to create a Netcore account and add your API key to the Netcore integration on the Novu platform.

# Generating an API Key

To generate a new API key in Netcore, you can follow these steps:

* [Log in](https://email.netcorecloud.com/) to your Netcore account.
* Go to the **Integration** page under the **Settings** menu and click on the **API** tab.
* The API Key is hidden for security purposes. Click Show. The system will prompt you to enter your account password. Once you enter the password, the API key will be accessible.

# Setting up sending domains

To start sending emails, you need to add and verify your sending domains. You can either use your top-level domain (e.g. my-company.com) or a sub-domain like email.my-company.com. The verification is done to ensure your sending domain’s security.

Follow the instructions on this [page](https://emaildocs.netcorecloud.com/docs/what-is-a-sending-domain-how-to-set-up-sending-domains) to get started

# Creating a Netcore integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-netcore) page on Novu.
* Click on Add a Provider.
* Select Netcore service.
* Enter your Netcore API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Netcore in Novu.


# Outlook 365
Source: https://v0.x-docs.novu.co/channels-and-providers/email/outlook365

Learn how to use the Outlook 365 provider to send email notifications using Novu

You can use the [Outlook 365](https://office.com/) provider to send transactional emails through your instance of Office 365 to your customers using the Novu Platform with a single API.

## Getting Started

To use the Outlook 365 provider in the email channel, you will need to have the sender's email (user) and the password for the account. This account cannot be a shared mailbox or distribution list. It will need to be properly licensed to send email via Office 365.

## Creating the Outlook 365 integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-office365) page on Novu.
* Click on Add a Provider.
* Select Outlook service.
* Enter your SMTP credentials
  * `from`: The Complete email address of the sending user. (e.g. [jdoe@mycompany.com](mailto:jdoe@mycompany.com))
  * `senderName`: Sender Name should be the same email address of the sending user. (e.g. [jdoe@mycompany.com](mailto:jdoe@mycompany.com))
  * `password`: Password used to sign in with the email account.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Outlook 365 in Novu.

<Note> In order to create outlook integration, turn off multi factor authentication from account security settings.</Note>


# Email providers
Source: https://v0.x-docs.novu.co/channels-and-providers/email/overview

Learn the process of configuring email providers with Novu

Novu can be used to deliver email messages to your customers using a unified delivery API. You can easily integrate your favorite email provider using the built-in integration store.

<iframe />

## Configuring email providers

When creating an email provider integration you will be asked to provide additional fields alongside the provider-specific credentials:

* **Sender name** - Will be displayed as the sender of the message
* **From email address** - Emails sent using Novu will be sent using this address

For some email providers including SendGrid you will have to authenticate the **From email address** to make sure you will send email messages using an authorized address.

## Sending Email Overrides

The overrides field supports an email property. The email overrides field have properties like `to`, `from`, `senderName` etc

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        email: {
          to: ['to@novu.co'],
          from: 'from@novu.co',
          senderName: 'Novu Team',
          text: 'text version of email using overrides',
          replyTo: 'no-reply@novu.co',
          cc: ['1@novu.co'],
          bcc: ['2@novu.co'],
        },
      },
    });
    ```
  </Tab>
</Tabs>

<Note>It's very important to know that Novu merges the `to` field in the email overrides with the subscriber email. It DOES NOT REPLACE IT.</Note>

### Overriding the selected layout

Layout can be selected in the email step editor. To use another layout with emails, selected layout can be overridden using layoutIdentifier in the overrides field.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        layoutIdentifier: 'layout-identifier-value',
      },
    });
    ```
  </Tab>
</Tabs>

## Sending Email attachments

You can easily send attachments with the Novu API by passing the attachments array when triggering an Email based workflow. Attachment file can either be in the `buffer` or `base64` format.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      payload: {
        attachments: [
          {
            file: fs.readFileSync(__dirname + '/data/novu.jpeg'),
            name: 'novu.jpeg',
            mime: 'image/jpeg',
          },
        ],
      },
    });
    ```
  </Tab>
</Tabs>

## Using different email integration

In Novu integration store, multiple email channel type provider integrations can be active at the same time. But only one  provider integration can be primary at a time. This primary integration will be used as a provider to deliver the email by default. If you want to use a different active provider integration then you can use the `integrationIdentifier` email overrides field.

If there are 4 active email integrations with these identifiers:-

1. sendgrid-abcdef
2. sendgrid-ghijkl
3. brevo-abcdef
4. mailersend-abcdef

Here, if `sendgrid-abcdef` is primary integration and you want to use `brevo-abcdef` with this trigger then you can use `integrationIdentifier` email overrides field as below:-

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        email: {
          integrationIdentifier: "brevo-abcdef"
        },
      },
    });
    ```
  </Tab>
</Tabs>

<Info> Integration identifier is similar to Provider identifier but it is different than Provider Id. It is unique for each integration.You can find the `integrationIdentifier` in the integration store page.  </Info>

<Tip>
  <MissingProvider />
</Tip>


# Plunk
Source: https://v0.x-docs.novu.co/channels-and-providers/email/plunk

Learn how to use the Plunk provider to send email notifications using Novu

You can use the [Plunk](https://useplunk.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Plunk provider in the email channel, you will need to create a Plunk account and add your API key to the Plunk integration on the Novu platform.

## Get API Key

To generate a new API key in Plunk, you can follow these steps:

* Log in to your Plunk account.
* Click on `Project Settings` on the side bar and then `API keys` on the tab.
* On the API Keys page, click on `Secret API key` to copy.

## Authenticate your sender identity

Before you can send emails on a large scale, you will need to authenticate your Sender Identity. Plunk allows you to authenticate your sender identity using [Domain Authentication](https://app.useplunk.com/settings/identity)

## Create a Plunk integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-plunk) page on Novu.
* Click on Add a Provider.
* Select Plunk service.
* Enter your Plunk secret API Key.
* Fill the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Plunk in Novu.


# Postmark
Source: https://v0.x-docs.novu.co/channels-and-providers/email/postmark

Learn how to use the Postmark provider to send email notifications using Novu

It is possible to use [Postmark](https://postmarkapp.com/) as a provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

The first step to use the Postmark provider in the email channel is to create a Postmark account and add the personal API key to the Postmark integration on the Novu platform.

# Getting the API Key

* To find the Postmark API key, log into the personal Postmark account and navigate to the servers page.
* After selecting the server to use, the API key (referred to as "Server API tokens") will be in the "API Tokens" section of the server chosen.

# Authenticating the sender's identity

Due to the latest regulatory changes regarding SPAM rules and email fraud, it is needed to authenticate the sender's identity before sending emails on a large scale. Most of the providers, including Postmark, require authentication to unlock the possibility of sending emails.

Postmark allows the authentication of the sender's identity using one of the following methods:

* [Single Sender Verification](https://account.postmarkapp.com/signatures/new) - This is the easiest way to authenticate the sender's identity.
* [Entire Domain Authentication](https://postmarkapp.com/support/article/1046-how-do-i-verify-a-domain#:~:text=be%20verified%20automatically.-,Navigate%20to%20Sender%20Signatures.,to%20your%20DNS%2C%20choose%20Verify.) - This is recommended for sending emails from multiple accounts under the same domain.

# Create a Postmark integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-postmark) page on Novu.
* Click on Add a Provider.
* Select Postmark service.
* Enter the Postmark API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* Now is possible to send notifications using Postmark in Novu.


# Resend
Source: https://v0.x-docs.novu.co/channels-and-providers/email/resend

Learn how to use the Resend provider to send email notifications using Novu

You can use the [Resend](https://resend.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Resend provider in the email channel, you will need to create a Resend account and add your API key to the Resend integration on the Novu platform.

# Generating an API Key

To generate a new API key in Resend, you can follow these steps:

* [Sign up](https://resend.com/secret) or [Log in](https://resend.com/login) to your Resend account.
* Click on the **API Keys** link in the left sidebar, and then click the "Create API Key" button on the top right part of the page.
* On the [API Keys](https://resend.com/api-keys) page, click the **Create API Key** button.
* Give the API key a name and click on the **Add** button.
* Copy the generated API Key.

# Authenticating your Sender Identity

Before you can send emails on a large scale, you will need to authenticate your Sender Identity.

Resend allows you to authenticate your sender identity using [Domain Authentication](https://resend.com/docs/dashboard/domains/introduction).

# Creating a Resend integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-resend) page on Novu.
* Click on Add a Provider.
* Select Resend service.
* Enter your Resend API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
  * For testing, you can use `onboarding@resend.dev` if you have not authenticated your sender identity.
* Fill in the `Sender's name`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Resend in Novu.


# SendGrid
Source: https://v0.x-docs.novu.co/channels-and-providers/email/sendgrid

Learn how to use the Sendgrid provider to send email notifications using Novu

You can use the [SendGrid](https://sendgrid.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Sendgrid provider in the email channel, you will need to create a Sendgrid account and add your API key to the SendGrid integration on the Novu platform.

## Generating an API Key

To generate a new API key in SendGrid, follow these steps:

* Log in to your SendGrid account.
* Click on the **Settings** gear icon in the top right corner of the screen, and then click "API Keys" from the drop-down menu.
* On the API Keys page, click the **Create API Key** button.
* Give the API key a name and select the following permissions
* **Mail Send** - Full Access
* (Optional) Template Engine - Read Only
* Click the **Create & View** button to generate the API key. The key will be displayed on the screen, but you will only be able to view it once, so make sure to save it in a safe place.

NOTE

The access level of the key will determine what actions the API Key can take, so please choose the correct one.

* **Mail Send** - Full Access
* (Optional) Template Engine - Read Only

## Authenticating your [Sender Identity](https://docs.sendgrid.com/for-developers/sending-email/sender-identity)

Before you can send emails on a large scale, you will need to authenticate your Sender Identity. This is due to the latest regulatory changes regarding SPAM rules and email fraud. Most of the providers including Sendgrid require you to authenticate your Sender Identity before you can send emails.

SendGrid allows you to authenticate your sender identity using one of the following methods:

* [Single Sender Verification](https://docs.sendgrid.com/ui/sending-email/sender-verification) - This is the easiest way to authenticate your sender identity.
* [Entire Domain Authentication](https://docs.sendgrid.com/ui/account-and-settings/how-to-set-up-domain-authentication) - This is recommended if you are sending emails from multiple accounts under your domain.

## SendGrid integration with Novu

* Visit the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-sendgrid) on the Novu web dashboard.
* Click on Add a Provider.
* Select SendGrid service.
* Enter your SendGrid API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications through SendGrid using Novu.

## Using SendGrid template

Novu has its own email editor for writing email template. If you want to use pre made template from SendGrid, you can use `customData` filed of email overrides to send template details. Make sure your `Api Key` has enough permission to read and process the template.

<Info>customData override is available from version 0.21.0</Info>

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.trigger("workflowIdentifier", {
      to: "subscriberId",
      payload: {},
      overrides: {
        email: {
          customData: {
            // sendgrid template templateId
            templateId: 'sendgrid-template-id',
            // sendgrid template variables
            dynamicTemplateData: {
              total: '$ 239.85',
              items: [{
                  text: 'New Line Sneakers',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png',
                  price: '$ 79.95',
                },
                {
                  text: 'Old Line Sneakers rlfjrjrh4hr4rh4',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png',
                  price: '$ 79.95',
                },
              ],
              receipt: true,
              name: 'Sample Name',
              address01: '1234 Fake St.',
              address02: 'Apt. 123',
              city: 'Place',
              state: 'CO',
              zip: '80202',
            },
          },
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl --location 'https://api.novu.co/v1/events/trigger' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <NOVU_API_KEY>' \
    --data '{
        "name": "workflowIdentifier",
        "to":  ["subscriberId"],
        "payload": {},
        "overrides": {
            "email": {
                "customData": {
                    "templateId": "sendgrid-template-id",
                    "dynamicTemplateData": {
                        "total": "$ 239.85",
                        "items": [
                            {
                                "text": "New Line Sneakers",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png",
                                "price": "$ 79.95"
                            },
                            {
                                "text": "Old Line Sneakers rlfjrjrh4hr4rh4",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png",
                                "price": "$ 79.95"
                            }
                        ],
                        "receipt": true,
                        "name": "Sample Name",
                        "address01": "1234 Fake St.",
                        "address02": "Apt. 123",
                        "city": "Place",
                        "state": "CO",
                        "zip": "80202"
                    }
                }
            }
        }
    }'
    ```
  </Tab>
</Tabs>


# Sendinblue
Source: https://v0.x-docs.novu.co/channels-and-providers/email/sendinblue

Learn how to use the Sendinblue provider to send email notifications using Novu

You can use the [Sendinblue](https://www.sendinblue.com/) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the Sendinblue provider in the email channel, you will need to create a Sendinblue account and add your API key to the Sendinblue integration on the Novu platform.

# Finding the API Key

* To find your Sendinblue API key, log into your Sendinblue account and navigate to the [API Keys](https://account.sendinblue.com/advanced/api) page.

# Authenticating your sender identity

Before you can send emails on a large scale, you will need to authenticate your sender's identity. This is due to the latest regulatory changes regarding SPAM rules and email fraud. Most of the providers including Sendinblue require you to authenticate your sender identity before you can send emails.

Sendinblue allows you to authenticate your sender identity using one of the following methods:

* [Single Sender Verification](https://account.sendinblue.com/senders) - This is the easiest way to authenticate your sender identity.
* [Entire Domain Authentication](https://help.sendinblue.com/hc/en-us/articles/115000185270-What-is-a-verified-domain-on-Sendinblue-) - This is recommended if you are sending emails from multiple accounts under your domain.

# Creating a Sendinblue integration with Novu

* Visit the [Integrations store](https://web.novu.co/integrations?utm_campaign=docs-sendinblue) on the Novu web dashboard.
* Click on Add a Provider.
* Select Sendinblue service.
* Enter your Sendinblue API key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using Sendinblue in Novu.

## Using Sendinblue template

Novu has its own email editor for writing email template. If you want to use pre made template from Sendinblue, you can use `customData` filed of email overrides to send template details. Make sure your `Api Key` has enough permission to read and process the template.

<Info>customData override is available from version 0.21.0</Info>

<Tabs>
  <Tab title="Node.js">
    ```jsx theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.subscribers.trigger("workflowIdentifier", {
      to: "subscriberId",
      payload: {},
      overrides: {
        email: {
          customData: {
            // sendinblue template templateId
            templateId: 1,
            // sendinblue template variables
            templateParams: {
              total: '$ 239.85',
              items: [{
                  text: 'New Line Sneakers',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png',
                  price: '$ 79.95',
                },
                {
                  text: 'Old Line Sneakers rlfjrjrh4hr4rh4',
                  image: 'https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png',
                  price: '$ 79.95',
                },
              ],
              receipt: true,
              name: 'Sample Name',
              address01: '1234 Fake St.',
              address02: 'Apt. 123',
              city: 'Place',
              state: 'CO',
              zip: '80202',
            },
          },
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId",
      tenant: "tenantIdentifier"
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl --location 'https://api.novu.co/v1/events/trigger' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <NOVU_API_KEY>' \
    --data '{
        "name": "workflowIdentifier",
        "to":  ["subscriberId"],
        "payload": {},
        "overrides": {
            "email": {
                "customData": {
                    "templateId": 1,
                    "templateParams": {
                        "total": "$ 239.85",
                        "items": [
                            {
                                "text": "New Line Sneakers",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png",
                                "price": "$ 79.95"
                            },
                            {
                                "text": "Old Line Sneakers rlfjrjrh4hr4rh4",
                                "image": "https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png",
                                "price": "$ 79.95"
                            }
                        ],
                        "receipt": true,
                        "name": "Sample Name",
                        "address01": "1234 Fake St.",
                        "address02": "Apt. 123",
                        "city": "Place",
                        "state": "CO",
                        "zip": "80202"
                    }
                }
            }
        }
    }'
    ```
  </Tab>
</Tabs>


# Sparkpost
Source: https://v0.x-docs.novu.co/channels-and-providers/email/sparkpost

Learn how to use the Sparkpost provider to send email notifications using Novu

You can use the [SparkPost](https://messagebird.com/email/cloud-sending) provider to send transactional emails to your customers using the Novu Platform with a single API.

# Getting Started

To use the SparkPost provider in the email channel, you will need to create a SparkPost account and add your API key to the SparkPost integration on the Novu platform.

# Generating an API Key

To generate a new API key in SparkPost, you can follow these steps:

* [Sign up](https://app.sparkpost.com/join) or [Log in](https://app.sparkpost.com/auth) to your SparkPost account.

  > During sign up, note that SparkPost is available in multiple regions. "SparkPost" refers to the SparkPost service hosted in North America. "SparkPost EU" refers to the SparkPost service hosted in Western Europe. An account created with SparkPost cannot be used with SparkPost EU, and vice-versa. You may use accounts in both regions.
  >
  > \~ *[SparkPost Documentation](https://support.sparkpost.com/docs/getting-started/getting-started-sparkpost/)*
* Click on the **Configuration** link on the navbar, and then click the "API Keys" link that pops up from the available options.
* On the [API Keys](https://app.sparkpost.com/account/api-keys) page, click the **Create API Key** button.
* Give the API key a name and click on the **Create API key** button.
* Copy the generated API Key.

# Authenticating your Sender Identity

Before you can send emails on a large scale, you will need to authenticate your Sender Identity.

SparkPost allows you to authenticate your sender identity using [Sending Domains](https://app.sparkpost.com/domains/list/sending).

# Creating a SparkPost integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sparkpost) page on Novu.
* Click on Add a Provider.
* Select SparkPost service.
* Enter your SparkPost API Key.
* Fill in the `From email address` field using the authenticated email from the previous step.
* Fill in the `Sender's name`.
* Toggle the `eu` switch to true if you're in Western Europe
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Update** button.
* You should now be able to send notifications using SparkPost in Novu.


# Introduction
Source: https://v0.x-docs.novu.co/channels-and-providers/in-app/introduction

Learn how to integrate In-App notification center and send In-App notification using Novu

In-app notifications are messages or alerts that appear within a mobile app or website while a user is actively using it. Unlike push notifications, which can reach users even when they're not actively engaged with an app, in-app notifications are designed to enhance the user experience within the app itself. Here's why they are important:

1. User Engagement: In-app notifications can keep users engaged and informed while they are using your app, providing valuable updates, reminders, or information relevant to their current activity. This can improve user satisfaction and encourage them to spend more time within the app.

2. Personalization: In-app notifications can be highly personalized based on a user's behavior, preferences, or location within the app. This personalization can lead to a more tailored and relevant user experience, increasing the likelihood of conversions or desired actions.

3. Onboarding and Education: In-app notifications are useful for guiding users through the app's features and functions, helping newcomers understand how to use the app effectively. They can also provide tips, tutorials, and educational content to enhance user proficiency.

4. Feedback and Surveys: In-app notifications can prompt users to provide feedback, complete surveys, or rate the app. Gathering user feedback within the app allows for real-time insights and improvements, contributing to app quality and user satisfaction.

5. Transactional Updates: In e-commerce or service apps, in-app notifications are crucial for providing order confirmations, shipping updates, payment receipts, and other transaction-related information, ensuring users are kept informed about important actions they've taken within the app.

6. Reduced Interruption: Unlike push notifications, in-app notifications are less intrusive since they only appear when users are actively engaged with the app. This can lead to a more seamless and focused user experience.

7. User Retention: By delivering timely and relevant information, in-app notifications can help retain users and reduce churn rates. Users who find value in the app are more likely to continue using it over time.

8. A/B Testing and Optimization: In-app notifications can be A/B tested to determine which messages and designs are most effective in achieving specific goals, such as increasing conversions or user engagement.

## In-app notifications using Novu

<iframe />

Novu provides a pre built component to display in-app notifications for almost all web frameworks. You can use this component to display in-app notifications in your web app. If you don't want to use the pre built component, you can use the headless component to build your own in-app notification center. Read more about notification center [here](/notification-center/introduction).


# Integration Store
Source: https://v0.x-docs.novu.co/channels-and-providers/integration-store

Learn about Novu's integration store

## Introduction

Novu's integration store serves as the central hub from where you can seamlessly enable and disable various services for efficient communication.

This feature simplifies the process of managing your communication channels. You can see which provider is enabled/disabled for what channel, which provider works in what environment and more. Moreover, it provides a clear overview of enabled and disabled services, offering you greater control over your communication strategy.

<Frame>
  <img />
</Frame>

From this image above, you can see that I've configured `Sendgrid` and `Twilio` as my email and sms provider respectively and both are in the `development` environment.

## Streamline Communication Services

With the Integration Store, you can streamline your communication services effortlessly. Whether it's Email, Chat, or SMS, this feature allows you to integrate different communication channels with ease. This centralization ensures that you can manage all your services conveniently from a single location.

## Enabling and Disabling Services

The Integration Store allows you to activate or deactivate specific services according to your communication needs. You can enable a service by simply entering the required `API key`, `identifier` and other required info depending on the provider you're choosing. Conversely, if you need to deactivate a service temporarily or make changes, you can disable it just as effortlessly.

## Enhanced Flexibility

By providing a comprehensive range of communication services under one roof, the Integration Store enhances your flexibility. You have the power to customize your communication strategy by enabling the services that align with your requirements.

## Conclusion

Novu's integration store offers a centralized and user-friendly platform for managing your communication services effectively. With its categorization, clear visibility, and easy enablement/disabling of services, you can fine-tune your communication strategy and streamline your interactions, enhancing the overall communication experience of your product.


# Overview
Source: https://v0.x-docs.novu.co/channels-and-providers/introduction

Learn about what channels, providers and oganizations are

## Channels:

Novu lets you send notifications across different communication mediums, including emails, in-app messages, push notifications, SMS, and chat. Each of these five communication mediums is referred to as a notification ‘channel’.

<Frame>
  <img />
</Frame>

## Providers:

Providers are what allow us to handle message delivery over multiple channels. Of the five notification channels that Novu currently supports, each channel except the ‘in-app’ channel has multiple providers.

The in-app channel only has one provider (the default Novu provider).

All the remaining channels have multiple providers.

## Organizations:

Organizations enable you to segregate notifications across multiple products that you may have. You can use Novu to send notifications across multiple apps and can create organizations.

<Frame>
  <img />
</Frame>

<Warning>Credentials are saved per instance of the active integrations of a provider. In case of more than one active provider of the same type, If `integrationIdentifier` is not sent in [this](https://docs.novu.co/api-reference/subscribers/update-subscriber-credentials) API, then the most recently created provider will be used to update the credentials.</Warning>


# Apple Push Notification Service (APNS)
Source: https://v0.x-docs.novu.co/channels-and-providers/push/apns

Learn how to use the Apple Push Notification Service (APNS) provider to send push notifications using Novu

[Apple Push Notification Service](https://docs.expo.dev/push-notifications/overview/), as the name suggests, is a notification delivery service provided by Apple.

Apple provides two authentication methods to make a secure connection to APNs. The first is Certificate-Based Authentication (using a .p12 certificate). The second is Token-Based Authentication (using a .p8 key). We'll make use of the **.p8** key.

To enable APNS integration, you need to create an [Apple Developer](https://developer.apple.com/) account with an [Admin role](https://appstoreconnect.apple.com/access/users).

To generate the p8 key for your account:

1. Head over to **Certificates, Identifiers & Profiles > Keys**.
2. Register a new key and give it a name.
3. Enable the Apple Push Notifications service (APNs) checkbox by selecting it.
4. Click the **Continue** button and on the next page, select **Register**.
5. Download the **.p8** key file.

You also need the following to connect to APNs:

1. **Key ID** - This is a 10-character unique identifier for the authentication key. You can find it in the key details section of the newly created key in your Apple developer account.
2. **Team ID** - This is available in your Apple developer account.
3. **Bundle ID** - This is the ID of your app. You can find it in the app info section of your Apple developer account.

The overrides field supports all [Notification payload](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/generating_a_remote_notification?language=objc) values, as shown below:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    abc: 'def', // If the notification is a data notification, the payload will be sent as the data
  },
  overrides: {
    apns: {
      payload: {
        aps: {
          notification: {
            title: 'Test',
            body: 'Test push',
          },
          data: {
            key: 'value',
          },
        },
      },
    },
  },
});
```

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    key1: 'val1',
    key2: 'val2', // If the notification is a data notification, the payload will be sent as the data
  },
  overrides: {
    type: 'data',
    apns: {
      headers: {
        'apns-priority': '5',
      },
      payload: {
        aps: {
          alert: {
            'loc-key': 'GAME_PLAY_REQUEST_FORMAT',
            'loc-args': ['Shelly', 'Rick'],
          },
          sound: 'demo.wav',
        },
      },
    },
  },
});
```

Before triggering the notification to a subscriber(user) with push as a step in the workflow, make sure you have added the subscriber's device token as follows:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.APNS, {
      deviceTokens: ['token1', 'token2'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "apns",
      "deviceTokens": ["token1", "token2"],
      "integrationIdentifier": "apns-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.


# Expo Push
Source: https://v0.x-docs.novu.co/channels-and-providers/push/expo-push

Learn how to use the Expo push provider to send push notifications using Novu

[Expo Push](https://docs.expo.dev/push-notifications/overview/) is a notification delivery service provided by Expo.

To enable Expo Push integration, you need to create an [Expo Application Services (EAS)](https://expo.dev/)account and generate an access token in the EAS dashboard.

The overrides field supports all [Message Request](https://docs.expo.dev/push-notifications/sending-notifications/#message-request-format) values. An example of the same follows:

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    abc: 'def',
  },
});
```

Before triggering the notification to a subscriber(user) with push as a step in the workflow, make sure you have added the subscriber's device token as follows:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,PushProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.EXPO, {
      deviceTokens: ['token1', 'token2'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "expo",
      "deviceTokens": ["token1", "token2"],
      "integrationIdentifier": "expo-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.


# Firebase Cloud Messaging (FCM)
Source: https://v0.x-docs.novu.co/channels-and-providers/push/fcm

Learn how to use the Firebase Cloud Messaging (FCM) provider to send push notifications using Novu

[Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging) is a free notification delivery service provided by Google Firebase.

To enable the FCM integration, you need to get your service account key from the [Firebase Console](https://console.firebase.google.com/).

## Generating a Service Account Key JSON

To acquire the account key JSON file for your service account

1. Select your project, and click the gear icon on the top of the sidebar.
2. Head to project settings.
3. Navigate to the service account tab.
4. Click **Generate New Private Key,** then confirm by clicking **Generate Key.**
5. Clicking **Generate Key** downloads the JSON file.

After that, paste the entire JSON file content in the Service Account field of the FCM provider in the integration store on Novu’s web dashboard.

Make sure your service account json content contains these fields

```json theme={null}
{
  "type": "service_account",
  "project_id": "PROJECT_ID",
  "private_key_id": "PRIVATE_KEY_ID",
  "private_key": "PRIVATE_KEY",
  "client_email": "FIREBASE_ADMIN_SDK_EMAIL",
  "client_id": "CLIENT_ID",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "CLIENT_X509_CERT_URL"
}
```

## FCM Overrides

The overrides field supports apns, android, webpush and fcmOptions overrides

| Override Field | Type / Interface | Link                                                                                                                                                                                         |
| -------------- | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| android        | AndroidConfig    | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.androidconfig](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.androidconfig) |
| apns           | ApnsConfig       | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.apnsconfig](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.apnsconfig)       |
| webPush        | WebpushConfig    | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.webpushconfig](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.webpushconfig) |
| fcmOptions     | FcmOptions       | [https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.fcmoptions](https://firebase.google.com/docs/reference/admin/node/firebase-admin.messaging.fcmoptions)       |

## Setting Device Token

Before triggering the notification to a subscriber(user) with push as a step in the workflow, make sure you have added the subscriber's device token as follows:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      PushProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials(
      'subscriberId', 
      PushProviderIdEnum.FCM, 
      { deviceTokens: ['token1', 'token2'] }, 
      'fcm-MnGLxp8uy'
    );
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "fcm",
      "credentials": {
        "deviceTokens" : [
          "token1", 
          "token2"
        ]
      },
      "integrationIdentifier": "fcm-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

## SDK Trigger Example

```jsx theme={null}
import { Novu } from "@novu/node";

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
  to: {
    subscriberId: "<SUBSCRIBER_ID>",
  },
  payload: {
    abc: "def", // If the notification is a data notification, the payload will be sent as the data
  },
  overrides: {
    fcm: {
      // type: 'data' => will turn this into an FCM data notification, where the payload is sent as a data notification. If the type is not set, you can use the "data" override to send notification messages with optional data payload
      type: "data",

      // URL of an image to be displayed in the notification.
      imageUrl: "https://domain.com/image.png",

      // If type is not set, you can use the "data" override to send notification messages with optional data payload
      data: {
        key: "value",
      },

      // Check FCM Overrides section above for these types
      android: {},
      apns: {},
      webPush: {},
      fcmOptions: {},
    },
  },
});
```

Device/notification identifiers can be set by using [setCredentials](#set-device-token) or by using the `deviceIdentifiers` field in overrides.

<Info> Novu uses FCM version V1</Info>

## Relative Link in Webpush

Suppose you’re using the Firebase (FCM) provider to send push notifications to web browsers via Novu and want users to be returned to the website after clicking the notification.

In that case, you must use the `link` property with a relative URL.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from "@novu/node";

    const novu = new Novu("<NOVU_API_KEY>");

    novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
      to: {
        subscriberId: "<SUBSCRIBER_ID>",
      },
      payload: {
        abc: "def", // If the notification is a data notification, the payload will be sent as the data
      },
      overrides: {
        fcm: {
          webPush: {
            fcmOptions: {
              link: "/foo",
            },
          },
        },
      },
    });
    ```
  </Tab>

  <Tab title="Curl">
    ```bash theme={null}
    curl --location --request POST 'https://url.to.our.selfhosted.novu' \
        --header 'Authorization: ApiKey KEY' \
        --header 'Content-Type: application/json' \
        --data-raw '{
            "name": "workflow-name",
            "to": {
                ...
            },
            "overrides": {
              "fcm": {
                "webPush": {
                  "fcm_options": {
                    "link": "/foo"
                  }
                }
              }
            }
          }'
    ```
  </Tab>
</Tabs>

## FCM Cost

As per Firebase [pricing](https://firebase.google.com/pricing), **Cloud Messaging** product is free of cost to use. If other Firebase products are used, the cost will be charged as per the product.

## FAQs

<AccordionGroup>
  <Accordion title="The registration token is not a valid FCM registration token">
    You may come across an error like so:

    ""Sending message failed due to "The registration token is not a valid FCM registration token""".

    This error happens because of invalid or stale token. The fix for this is to remove old tokens, generate a new token and save it into user subscribers.
  </Accordion>

  <Accordion title="FCM notifications sent successfully with no error but push notification is not received in device">
    Try to generate a new token after clearing device cache and retry with this fresh token.
  </Accordion>

  <Accordion title="Sending message failed due to 'Requested entity was not found'">
    This error occurs when your token is no longer valid. To fix this, generate a new token and use it.
  </Accordion>

  <Accordion title="Subscriber does not have a configured channel error">
    This error occurs if the fcm integration is active but subscriber is missing from the fcm credentials (deviceTokens). The credentials (deviceTokens) for the subscriber needs to be set.
  </Accordion>
</AccordionGroup>


# Onesignal
Source: https://v0.x-docs.novu.co/channels-and-providers/push/onesignal

Learn how to use the Onesignal provider to send push notifications using Novu

[OneSignal](https://onesignal.com/) is a paid push notification service that supports sending messages via both [Apple Push Notification Service](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server) (APNs) as well as [Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging) (FCM).

To configure the OneSignal integration, you will need an active account which has credentials for APNs, FCM or both, and have access to the `OneSignal App ID` and `Rest API Key` available via your [application's settings page](https://documentation.onesignal.com/docs/keys-and-ids).

# Setting the Device Token

Once OneSignal has been configured with your credentials for APNs/FCM, and the OneSignal SDK has been [set up and configured](https://documentation.onesignal.com/docs/onboarding-with-onesignal#step-1-setup-onesignal-sdk) for your application, your users will begin to be automatically assigned a unique OneSignal [player\_id](https://documentation.onesignal.com/docs/users#player-id) identifier by the SDK.

This identifier allows targeting your user when sending push notifications without having to retrieve the specific Android or iOS device tokens - which are managed by OneSignal.

In order to target the OneSignal user from Novu, you must register the OneSignal `player_id`as the `deviceToken` for your Novu subscriber. This value can be retrieved via the [OneSignal SDK](https://documentation.onesignal.com/docs/users-and-devices#finding-users) for your platform.

Once you have the user's `player_id` value, the `deviceToken` for your Novu subscriber can be set via:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.OneSignal, {
      // Your user's unique 'player_id' from OneSignal
      deviceTokens: ['ad0452ca-3ca7-43b5-bf9b-fa93fd322035'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "one-signal",
      "deviceTokens": ["ad0452ca-3ca7-43b5-bf9b-fa93fd322035"],
      "integrationIdentifier": "one-signal-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

# SDK Trigger Example

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    abc: 'def', // If the notification is a data notification, the payload will be sent as the data
  },
});
```

Device/notification identifiers can be set by using [setCredentials](https://docs.novu.co/channels/email/resend/#set-device-token) or by using the `deviceIdentifiers` field in overrides.


# Push Channel Introduction
Source: https://v0.x-docs.novu.co/channels-and-providers/push/overview

Learn how to send push notifications with Novu using external providers like FCM, Expo etc.

Push notifications are short, targeted messages delivered to a user's device or browser, often through mobile apps or websites. They serve as a powerful communication tool, offering real-time updates, reminders, and personalized content. Push notifications can range from news alerts and social media updates to promotional offers and important app notifications.

These messages are designed to engage users and keep them informed about relevant events or activities, even when they are not actively using an app or browsing a website. They play a crucial role in user engagement and retention for businesses and organizations, as they can re-engage users and prompt them to take specific actions.

Novu can be used to deliver push notifications to your customers devices using a unified delivery API. Both Mobile and Web push notifications are supported.

## Using push channel with Novu

To send a push notification to subscribers (users) using Novu:

* Add a push channel provider in integration store
* Add push channel as a step in existing or new workflow.
* Add static or dynamic content using variables in push step fields
* Store provider specific device tokens/identifiers in subscriber profile. Read provider specific documentation on how to obtain and store device tokens.
* Make sure all provider specific steps are configured properly before triggering workflow. Read provider related documentation for all required steps.
* Trigger the workflow.

## Supported providers

* [Firebase Cloud Messaging (FCM)](/channels-and-providers/push/fcm)
* [Expo Push](/channels-and-providers/push/expo-push)
* [Apple Push Notification Service](/channels-and-providers/push/apns)
* [OneSignal](/channels-and-providers/push/onesignal)
* [Pushpad](/channels-and-providers/push/pushpad)
* [Push Webhook](/channels-and-providers/push/push-webhook)

<Note>Novu supports multiple active providers for push channel.</Note>

<Tip>
  <MissingProvider />
</Tip>

## Managing push device tokens

To send push notifications to subscribers, you need to store device tokens or identifiers in subscriber profiles. These tokens are unique identifiers that help push notification providers deliver messages to the correct devices. Each provider has its own method for obtaining and storing device tokens.

Novu offers to ways of keeping your device tokens in sync with subscriber profiles:

* Just-in-time: Pass device tokens in the payload when triggering a workflow. Novu will automatically update subscriber profiles with the new device tokens.
* Manual: Update subscriber profiles with device tokens using the Novu Set Credentials API.

### Just-in-time

When triggering a workflow, you can pass the `channels` array on the subscriber object with the device tokens for the push provider of your choice. Here is an example with fcm:

```typescript theme={null}
novu.trigger('workflow-id', {
  to: {
    subscriberId: 'subscriber-id',
    channels: [
      {
        providerId: 'fcm',
        credentials: {
          deviceTokens: ['token-1', 'token-2'],
        },
      },
    ],
  },
  payload: {},
});
```

### Manual

Use the Novu Set Credentials API to update subscriber profiles with device tokens. You can read more about the API in the [API Reference](/api-reference/subscribers/update-subscriber-credentials) or the [FCM Example](/channels-and-providers/push/fcm#setting-device-token)

## Frequently Asked Questions

### How to remove one device token from subscriber credentials?

To remove a device token from subscriber credentials, you need to get the current device tokens from subscriber credentials, remove all deviceTokens, remove the token you want to remove and then update the subscriber credentials with new device tokens.

<Tabs>
  <Tab title="Node.js">
    ```ts theme={null}
    import { Novu, PushProviderIdEnum } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    // fetch subscriber details
    const subscriber = await novu.subscribers.get('subscriberId');

    // get current device tokens from subscriber credentials for the provider
    const currentDeviceTokens = subsciber.data.data.channels.find(
        // _integrationId can also be checked in place of providerId ;
        (channel) => channel.providerId === PushProviderIdEnum.FCM,
    ).credentials.deviceTokens;

    // remove all device tokens
    await this.novu.subscribers.setCredentials(
        'subscriberId',
        PushProviderIdEnum.FCM,
        { deviceTokens: [] },
    );

    // remove the token you want to remove
    const newDeviceTokens = currentDeviceTokens.filter(
        (token) => token !== 'token-to-be-removed',
    );

    // update subscriber credentials with new device tokens
    await this.novu.subscribers.setCredentials(
        'subscriberId',
        PushProviderIdEnum.FCM,
        { deviceTokens: newDeviceTokens },
    );
    ```
  </Tab>
</Tabs>


# Push Webhook
Source: https://v0.x-docs.novu.co/channels-and-providers/push/push-webhook

Learn how to use the Push Webhook provider to send  notifications using Novu

Push Webhook provider is a bit different different from other push providers as it does not depend on other third party services.
Users can use their own api url as webhook url and novu will make a post request on that webhook url.

## Steps To Configure

1. Go to [integration store](https://web.novu.co/integrations?utm_campaign=docs-push-webhook) and click on `Add a provider` button. Choose `Push` channel and then `Push Webhook` provider.
2. Enter your Webhook URL. For quick testing use [this](https://webhook.site/) website.
3. Enter Secret Hmac Key. Novu will use this secret hmac key to encrypt the data using `HMAC SHA256` algorithm and send the hash as value of `x-novu-signature` header. User can use `x-novu-signature` header to test authenticity of the request. Read more [here](#checking-authenticity)
4. Click on the update button.
5. Update the subscriber credentials using SDK or API. Read more [here](#set-device-token)

<Info>Your webhook url should accept `POST` request.</Info>

## Set Device Token

This step is a mandatory step. Other push providers have third party dependencies where a device token can be generated. But in case of push webhook provider, there is no any way to generate device token. Any random string can be used as device token.

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    // PushProviderIdEnum.PushWebhook = push-webhook
    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.PushWebhook, {
      deviceTokens: ['ANY_RANDOM_STRING'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "push-webhook",
      "deviceTokens": ['ANY_RANDOM_STRING'],
      "integrationIdentifier": "push-webhook-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

## Example paylod sent by novu to webhook url

```json theme={null}
{
  "target": [
    "subscriber-token-for-push-webhook-provider"
  ],
  "title": "Push Webhook message title",
  "content": "push Webhook content body",
  "overrides": {
    "data": {
      "custom_message": "this is custom message from payload push webhook demo",
    }
  },
  "payload": {
    "custom_message": "this is custom message from payload push webhook demo",
    "__source": "test-workflow",
    "subscriber": {
      // subscriber fields
      "_id": "65c0d71c0959a38e8857b131",
      "_organizationId": "organizationId",
      "_environmentId": "environmentId",
      "firstName": "Pawan",
      "lastName": "Jain",
      "phone": "+123456789",
      "subscriberId": "push-webhook-demo-subscriber-id",
      "email": "pawan+push+web+hook+demo@domain.com",
      "channels": [
        {
          "credentials": {
            "deviceTokens": [
              "subscriber-token-for-push-webhook-provider"
            ]
          },
          "_integrationId": "integrationId",
          "providerId": "push-webhook"
        }
      ],
      "data": {
        // custom data field of subscriber
        "isDeveloper": "true"
      },
      "deleted": false,
      "createdAt": "2024-02-05T12:39:56.379Z",
      "updatedAt": "2024-02-05T12:54:08.684Z",
      "__v": 0,
      "id": "65c0d71c0959a38e8857b131"
    },
    "step": {
      // digest variables
      "digest": false,
      "events": [],
      "total_count": 0
    }
  }
}
```

## Checking Authenticity

```typescript theme={null}
import crypto from "crypto"

// secret key added in step 3
const secretKey = "YOUR_HMAC_SECRET_KEY"

// function to handle webhook url route request
async acceptNovuPushWebHookRequest(request, response){

  const payloadSentByNovu = request.body
  const hmacHashSentByNovu = request.headers['x-novu-signature']

  const actualHashValue = crypto
    .createHmac('sha256', secretKey)
    .update(payloadSentByNovu, 'utf-8')
    .digest('hex');

  if(hmacHashSentByNovu === actualHashValue){
    // handle the notification
    console.log("Request sent by Novu")
  } else {
    throw new Error("Not a valod request")
  }
}
```


# Pusher Beams
Source: https://v0.x-docs.novu.co/channels-and-providers/push/pusher-beams

Learn how to use the Pusher Beams provider to send push notifications using Novu

[Pusher Beams](https://pusher.com/beams/) is a cross-platform push notification API service provided by Pusher.

To enable Pusher Beams integration, you need to create a Pusher Beams Instance and use both `Instance ID` and `Secret Key` from the Instance [dashboard](https://dashboard.pusher.com/beams/).

# Setting the Device Token

Once Pusher Beams instance has been created, and the Pusher Beams SDK has been [set up and configured](https://pusher.com/docs/beams/reference/all-libraries/) for your application, you can associate users with their devices using [Authenticated Users](https://pusher.com/docs/beams/guides/publish-to-specific-user/web/).

This identifier allows targeting your user when sending push notifications without having to retrieve the specific Web, Android or iOS device tokens - which are managed by Pusher Beams.

In order to target the Pusher Beams user from Novu, you must register the Pusher Beams Authenticated Users with their `userId` as the `deviceToken` for your Novu subscriber. This value can be retrieved via [getUserId()](https://pusher.com/docs/beams/reference/web/#getuserid) method from the SDK for your platform.

Once you have the user's `userId` value, the `deviceToken` for your Novu subscriber can be set via:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.PusherBeams, {
      // Your user's unique 'userId' from Pusher Beams
      deviceTokens: ['userId-from-pusher-beams'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "pusher-beams",
      "deviceTokens": ['userId-from-pusher-beams'],
      "integrationIdentifier": "pusher-beams-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

# SDK Trigger Example

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    custom_data: 'custom_data', // the payload will be sent as notification data object. Cannot contain the key “pusher”
  },
});
```


# Pushpad
Source: https://v0.x-docs.novu.co/channels-and-providers/push/pushpad

Learn how to use the Pushpad provider to send web push notifications using Novu

[Pushpad](https://pushpad.xyz) is a web push service that supports sending notifications to all major browsers (Chrome, Firefox, Edge, Safari, etc.) via FCM, Mozilla autopush, Windows Push Notification Services and Apple Push Notification service, with just one simple API.

To configure the Pushpad integration, you will need an active account and you need to have a `Pushpad Auth Token` (from the [account settings](https://pushpad.xyz/access_tokens)) and the `Pushpad Project ID` (from the project settings).

# Setting the Device Token

Once Pushpad has been configured with your credentials and the Pushpad SDK has been [set up and installed](https://pushpad.xyz/docs/pushpad_pro_getting_started) on your website, you can [assign a user ID (uid)](https://pushpad.xyz/docs/identifying_users) to the push subscriptions.

This identifier (`uid` or `user ID`) allows targeting a specific browser when sending push notifications.

In order to target the Pushpad user from Novu, you must register the Pushpad `uid` as the `deviceToken` for your Novu subscriber. For example, if you invoked the [Pushpad JavaScript SDK](https://pushpad.xyz/docs/javascript_sdk_reference) with `pushpad('uid', 'user123')`, then `user123` is the user ID for that browser.

Once you have the `uid` value, the `deviceToken` for your Novu subscriber can be set using this code:

<Tabs>
  <Tab title="Node.js">
    ```javaScript theme={null}
    import {
      Novu,
      ChatProviderIdEnum
    } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.subscribers.setCredentials('subscriberId', PushProviderIdEnum.Pushpad, {
      // the user ID (uid) that you used for Pushpad
      deviceTokens: ['user123'],
    });
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -H 'Authorization: ApiKey <NOVU_API_KEY>' \
    -d '{
      "providerId": "pushpad",
      "deviceTokens": ['user123'],
      "integrationIdentifier": "pushpad-MnGLxp8uy"
    }'
    ```
  </Tab>
</Tabs>

Checkout the [API reference](/api-reference/subscribers/update-subscriber-credentials) for more details.

# SDK Trigger Example

```jsx theme={null}
import { Novu } from '@novu/node';

const novu = new Novu("<NOVU_API_KEY>");

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {}
});
```

The devices of the subscriber that should receive the notifications can be set by using `setCredentials` or by using the `deviceIdentifiers` field in overrides.


# Africa's Talking
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/africas-talking

Learn how to use the Africa's Talking provider to send sms notifications using Novu

You can use [Africa's Talking](https://africastalking.com/) provider to send SMS messages to your customers using the Novu platform with a single API to create multi-channel experiences.

## Getting Started

To use Africa's Talking provider in the SMS channel, the first step is to create an Africa's Talking account and add your `API Key`, `username` and `Sender's ID` to Africa's Talking integration on the Novu platform.

## Creating a username

You’ll need to create an application to create a username in Africa’s Talking. To do so, follow the steps below:

* [Sign up](https://account.africastalking.com/auth/register) or [Log in](https://account.africastalking.com/auth/login) to your Africa's Talking account.
* Select the team you want your app to be in.

<Frame>
  <img />
</Frame>

* If you're a new user and don't have a team yet, you'll have to do so by clicking on New Team and entering your team name. Click on Save when you're done.

<Frame>
  <img />
</Frame>

* On the page that appears, click on the Create App button.
* On the pop-up that appears, enter your application name, username and select a country. Then click Save. The `username` is what you will use on the Novu platform.

<Frame>
  <img />
</Frame>

## Generating an API key

To generate a new API key, you can follow these steps:

<Note>
  Ensure you have created an app in your team.
</Note>

* Click on the app you created.

<Frame>
  <img />
</Frame>

* On the page that appears, click on Settings(on the menu on your left). This will display a dropdown. Click on API Key from the dropdown options.

<Frame>
  <img />
</Frame>

* On the page that appears, enter your password and click Generate.

<Frame>
  <img />
</Frame>

* Copy the API Key generated and paste it into the Novu platform or record it somewhere safe for later use because you will not see it from the dashboard on subsequent visits.

<Note>
  Once you've generated your API Key, wait about 3 minutes before testing it.
</Note>

## Getting your Sender's ID

Sender IDs allow you to brand your messages as you send them to your customers. There are two kinds of sender IDs, **shortcodes** and **alphanumerics**. The difference is that you can send and receive messages with shortcodes but only send messages with an alphanumeric.

To create a Short Code:

* On your app dashboard, click on SMS (on the menu on your left). This will display a dropdown. Click on `Shortcodes` from the dropdown options. This will also display a dropdown from which you can then click on `My Shortcodes` to view your codes.

<Frame>
  <img />
</Frame>

* If you have not created one yet, on the `Shortcodes` dropdown option, click on `Request`.
  On the page that appears, fill in the form and submit.

<Frame>
  <img />
</Frame>

## To create an Alphanumeric:

* On your app dashboard, click on SMS (on the menu on your left). This will display a dropdown. Click on `Alphanumerics` from the dropdown options. This will also display a dropdown from which you can then click on `My Alphanumerics` to view your codes.

<Frame>
  <img />
</Frame>

* If you have not created one yet, on the `Alphanumerics` dropdown option, click on `Request`.
  On the page that appears, fill in the form and submit

<Frame>
  <img />
</Frame>

* Once you're done, add either your short code or alphanumeric to the `from` field on the Novu platform.

## Creating an Africa's Talking integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-africastalking) page on Novu.
* Click the "Add a provider" button.
* Locate **Africa's Talking** under the SMS section and click on the **Connect** button.
* Enter the `API key`.
* Fill in the `username` field.
* Fill in the `from` field. This is your registered `short code` or `alphanumeric` value.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using Africa's Talking in Novu.


# AWS SNS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/aws-sns

Learn how to use the AWS SNS provider to send sms notifications using Novu

You can use the [AWS SNS](https://aws.amazon.com/sns/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To integrate AWS SNS on the Novu platform, you will need to have in AWS, an IAM user who has the `sns:Publish` permission.

# Create User

To create a user, log in to AWS Console and follow these steps:

* Go to the `IAM` service page.
* Create a new user with `sns:Publish` permission, or add `sns:Publish` permission to an existing user.
* Add the `Access Key` credential to the user and copy the `Access key ID` and the `Secret access key`.

For security reasons, it is suggested that you create a new User to use with Novu.

# Create an AWS SNS integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-sns) page on Novu.
* Click the "Add a provider" button.
* Locate **Amazon SNS** and click on the **Connect** button.
* Enter your `Access Key ID`, `Secret Access key`, and `AWS region`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Save** button.
* You should now be able to send SMS notifications using **Amazon SNS** in Novu.


# Azure SMS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/azure

Learn how to use the Azure SMS provider to send sms notifications using Novu

You can use the [Azure SMS](https://learn.microsoft.com/en-us/azure/communication-services/quickstarts/sms/send?tabs=windows\&pivots=platform-azcli) SMS provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use Azure SMS provider in the SMS channel, the first step is to create an Azure account and grab the communication services connection string from your account dashboard.

# Creating a Azure SMS integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-azure) page on Novu.
* Click the "Add a provider" button.
* Locate **Azure Sms** under the SMS section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `Connection string`.
* Enter the `From` value.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **Azure Sms** in Novu.


# BulkSMS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/bulk-sms

Learn how to use the BulkSMS provider to send sms notifications using Novu

You can use the [BurstSMS](https://bulksms.com/) provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use BulkSMS provider in the SMS channel, the first step is to create a BulkSMS account and create an [API token](https://www.bulksms.com/account/#!/advanced-settings/api-tokens).

# Creating a BulkSMS integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-bulksms) page on Novu.
* Click the "Add a provider" button.
* Locate **BulkSMS** under the SMS section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `API Token`.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **BulkSMS** in Novu.


# Clickatell
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/clickatell

Learn how to use the Clickatell provider to send sms notifications using Novu

You can use the [Clickatell](https://www.clickatell.com/) provider to send SMS messages to your customers using the Novu Platform.
Let's see how to do it:

## Getting Started

To use the [Clickatell](https://www.clickatell.com/) provider in the SMS channel, the first step is to [create a Clickatell account](https://www.clickatell.com/sign-up/) and add your API key to the Clickatell integration on the [Novu web dashboard](https://web.novu.co/integrations?utm_campaign=docs-sms-clickatell).

## Retrieving your API Key

To find your Clickatell API key:

* [Sign up](https://www.clickatell.com/sign-up/) or [Login](https://app.clickatell.com/signin) to your Clickatell account.
* Click on the `My Workspace`, and then click `SMS` in Channels Section.

<Frame>
  <img />
</Frame>

* Click on the `New SMS Setup`.

<Frame>
  <img />
</Frame>

* Select `API` then `Messaging Type` and click Next.

<Frame>
  <img />
</Frame>

* Select `Basic HTTP API` then `create a new HTTP API` and click Next.

<Frame>
  <img />
</Frame>

* Now fill in all details and Click Next.

<Frame>
  <img />
</Frame>

* Copy the API key and click complete.

<Frame>
  <img />
</Frame>

## Create a Clickatell integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-clickatell) page on Novu.
* Click the "Add a provider" button.
* Locate **Clickatell** under the SMS section and click on the **Connect** button.
* Enter your Clickatell API Key.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Clickatell** in Novu.


# Firetext
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/firetext

Learn how to use the firetext provider to send sms notifications using Novu

You can use the [firetext](https://www.firetext.co.uk) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the firetext provider in the SMS channel, the first step is to create a firetext account and add your API key and Sender ID to the firetext integration on the Novu platform.

* Note : Firetext is only available in uk region. Others may require additional verification.

## Retrieving your API Key

To find your firetext API key:

* [Sign up](https://app.firetext.co.uk/signup) or [Login](https://app.firetext.co.uk/) to your firetext account.
* Click on the `Settings` icon in the top right corner of the screen.

<Frame>
  <img />
</Frame>

* Now Click on the `API` in `My Settings` Section.

<Frame>
  <img />
</Frame>

* On the API Keys page, copy the `API key`.

<Frame>
  <img />
</Frame>

## Create a firetext integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-firetxt) page on Novu.
* Click the "Add a provider" button.
* Locate **firetext** under the SMS section and click on the **Connect** button.
* Enter your `firetext` API Key.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **firetext** in Novu.


# gupshup
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/gupshup

Learn how to use the gupshup provider to send sms notifications using Novu

You can use the [gupshup](https://www.gupshup.io/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the gupshup provider in the SMS channel, the first step is to create a gupshup account and add the Account Username and Password to the gupshup integration on the Novu platform.

# What is User id and Password?

* `userid` : The account number provided by the Enterprise SMS GupShup.
* `Password` : Password is provided by Gupshup for authentication of user id. The password must be the same as used to log on to the Enterprise SMS GupShup website.

# Creating a gupshup integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-gupshup) page on Novu.
* Click the "Add a provider" button.
* Locate **gupshup** under the SMS section and click on the **Connect** button.
* Enter the `User id`.
* Enter the `Password`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **gupshup** in Novu.


# Infobip - SMS
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/infobip

Learn how to use the Infobip provider to send sms notifications using Novu

You can use the [Infobip](https://www.infobip.com/developers/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Infobip provider in the SMS channel, you will need to create an Infobip account and add your API key and Base URL to the Infobip integration on the Novu platform.

## Retrieving your API Key

To Find a new API key in Infobip, you can follow these steps:

* [Sign up](https://www.infobip.com/signup) or [Log in](https://portal.infobip.com/login/) to your Infobip account.
* On the [Homepage](https://portal.infobip.com/homepage/), you'll see your API key.

<Frame>
  <img />
</Frame>

Alternatively, you can find the API key on the Developer Tools page.

* On the sidebar (on the left), click on `Developer Tools`.
* This will display a dropdown from which you can then click on `API Ksys` to view your API key.

<Frame>
  <img />
</Frame>

If you want to create an API key:

* Click on the `CREATE API KEY` button
* Fill the form
* Click on `GENERATE`

<Frame>
  <img />
</Frame>

## Finding the Base URL

To see your base URL, log in to the account. Once logged in, on the Homepage, you should see your base URL in this format: `xxxxx.api.infobip.com`.

<Frame>
  <img />
</Frame>

## Create an Infobip integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-infobip) page on Novu.
* Click the "Add a provider" button.
* Locate **Infobip** under the SMS section and click on the **Connect** button.
* Enter your Infobip API Key.
* Enter your Base URL.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

You should now be able to send SMS notifications using Infobip in Novu.


# MessageBird
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/messagebird

Learn how to use the messagebird provider to send sms notifications using Novu

You can use the [MessageBird](https://www.messagebird.com) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the MessageBird provider in the SMS channel, the first step is to create a [MessageBird account](https://www.messagebird.com/en/sign-up) and then generate an `Access Key` within the developers' section section of your MessageBird account. This access key is essential for authenticating your requests to the MessageBird API.

# Creating a MessageBird integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-messagebird) page on Novu.
* Click the "Add a provider" button.
* Locate **MessageBird** under the SMS section. Click it and the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `Access Key` value.
* Enter the `From` value.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **MessageBird** in Novu.


# Nexmo
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/nexmo

Learn how to use the Nexmo provider to send sms notifications using Novu

You can use the [Nexmo By Vonage](https://www.vonage.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Nexmo provider in the SMS channel, the first step is to create a Nexmo account and add the API key and API Secret to the Nexmo integration on the Novu platform.

# Finding the API key and secret

First, [sign up for a Vonage account](https://ui.idp.vonage.com/ui/auth/login) if you don't already have one, and make a note of your API key and secret on the [dashboard getting started page](https://dashboard.nexmo.com/getting-started-guide).

# Create a Nexmo integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-nexmo) page on Novu.
* Click the "Add a provider" button.
* Locate **Nexmo** under the SMS section and click on the **Connect** button.
* Enter the `API key` and `API Secret`.
* Enter a valid `From` email address.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.
* Now it is possible to send SMS notifications using **Nexmo** in Novu.


# SMS Channel Overview
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/overview

Learn the process of configuring and using sms providers with Novu

Novu can be used to deliver sms messages to your customers using a unified delivery API. You can easily integrate your favorite sms provider using the built-in integration store.

<iframe />

## Configuring SMS providers

When creating a SMS provider integration you will be asked to provide additional fields alongside the provider-specific credentials:

* **From** - Will be displayed as the sender of the SMS

Additional credentials can be API key, username, password or other provider specific credentials.

<Note>
  Some countries have strict restriction of using verified `from` sender id
  (name). Kindly check country and provider specific requirements first.
</Note>

## Sending SMS Overrides

The overrides field supports a `sms` property and `from`, `to`, `content` field overrides. This allows you to send a message to a different recipient, from a different sender, or with a different content.

```javascript theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  }
  overrides: {
    sms: {
      to: '+123012345678',
      from: 'Novu Team',
      content: 'This SMS message is from overrides'
    },
  },
});
```

## Using different SMS integration

In Novu integration store, multiple SMS channel type provider integrations can be active at the same time. But only one provider integration can be primary at a time. This primary integration will be used as a provider to deliver the SMS by default. If you want to use a different active provider integration then you can use the `integrationIdentifier` sms overrides field.

If there are 4 active SMS integrations with these identifiers:-

1. twilio-abcdef
2. twilio-ghijkl
3. firetext-abcdef
4. infobip-abcdef

Here, if `twilio-abcdef` is primary integration and you want to use `infobip-abcdef` with this trigger then you can use `integrationIdentifier` sms overrides field as below:-

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
      to: {
        subscriberId: '<SUBSCRIBER_ID>',
      },
      overrides: {
        sms: {
          integrationIdentifier: "infobip-abcdef"
        },
      },
    });
    ```
  </Tab>
</Tabs>

<Info> Integration identifier is similar to Provider identifier but it is different than Provider Id. It is unique for each integration. You can find the `integrationIdentifier` in the integration store page.  </Info>

## Common errors

Common errors and reason for these errors while sending sms messages using Novu.

1. Subscriber does not have a configured channel.
   * if the `from` field is missing / null / undefined.

<Tip>
  <MissingProvider />
</Tip>


# Plivo
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/plivo

Learn how to use the Plivo provider to send sms notifications using Novu

You can use the [Plivo](https://www.plivo.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Plivo provider in the SMS channel, the first step is to create a Plivo account and add the Account SID and Auth token to the Plivo integration on the Novu platform.

# Finding the Account SID and Auth token

[Sign up](https://console.plivo.com/accounts/register/) or [Login](https://console.plivo.com/accounts/login/) to your Plivo account, and make a note of your Account SID and Auth token on the [Plivo console page](https://console.plivo.com/dashboard/).

# Creating a Plivo integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-plivo) page on Novu.
* Click the "Add a provider" button.
* Locate **Plivo** under the SMS section and click on the **Connect** button.
* Enter the `Account SID`.
* Enter the `Auth token`.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Plivo** in Novu.


# Sendchamp
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/sendchamp

Learn how to use the Sendchamp provider to send sms notifications using Novu

You can use the [Sendchamp](https://www.sendchamp.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Sendchamp provider in the SMS channel, the first step is to create a Sendchamp account and add your API key and Sender ID to the Sendchamp integration on the Novu platform.

## Retrieving your API Key

To find your Sendchamp API key:

* [Sign up](https://my.sendchamp.com/signup) or [Login](https://my.sendchamp.com/login) to your Sendchamp account.
* Click on the Avatar icon in the top right corner of the screen, and then click `API & Integrations` from the drop-down menu.

<Frame>
  <img />
</Frame>

Alternatively, you can access the API key from the Accounts menu.

* Scroll to the bottom of the sidebar (on the left) and click on `Accounts`.
* This will display a dropdown from which you can then click on `API keys & Webhooks` to view your API key.

<Frame>
  <img />
</Frame>

* On the API Keys page, copy the Public access key.

<Frame>
  <img />
</Frame>

## Get your Sender's ID

The Sender ID represents the sender of the message to your customers.

To get your Sender's ID:

* On the sidebar (on the menu on your left), click on `SMS`. This will display a dropdown. Click on `Sender ID` from the dropdown options.
* On the page that appears, you'll find a list of your Sender IDs

<Frame>
  <img />
</Frame>

If you have not created one yet:

* Click on the `Create Sender ID` button to request a Sender ID.
* Fill in the form.
* Click on `Add Sender ID` button.

<Frame>
  <img />
</Frame>

Once it is approved, you can use your Sender ID as the from field on the Novu platform.

## Create a Sendchamp integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-sendchamp) page on Novu.
* Click the "Add a provider" button.
* Locate **Sendchamp** under the SMS section and click on the **Connect** button.
* Enter your Sendchamp API Key.
* Fill in the `From` field.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Sendchamp** in Novu.


# SimpleTexting
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/simpletexting

Learn how to use the SimpleTexting provider to send sms notifications using Novu

You can use the [SimpleTexting](https://simpletexting.com/) SMS provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use SimpleTexting provider in the SMS channel, the first step is to create a SimpleTexting account and grab your `API KEY` in your settings.

# Creating a SimpleTexting integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-simpletexting) page on Novu.
* Click the "Add a provider" button.
* Locate **SimpleTexting** under the SMS section and click on the **Next** button.
* Select Your Environment add condition (Optional).
* Click on the `Create` button.
* Click on the `Disabled` button and mark it as `Active`.
* Enter the `API Key`.
* Enter the `From` value.
* Click on the **Update** button.

Now it is possible to send SMS notifications using **SimpleTexting** in Novu.


# SMS77
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/sms77

Learn how to use the SMS77 provider to send sms notifications using Novu

It is possible to use the [SMS77](https://www.sms77.io/en) provider to send SMS messages to the customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the SMS77 provider in the SMS channel, the first step is to create an SMS77 account and add the personal API key to the SMS77 integration on the Novu platform.

# Find the API key

To find the SMS77 API key, log into the personal SMS77 account and navigate to the API Keys page by clicking on the 'Developer' tab present at the end of the sidebar. It is suggested to create a new API key for use with Novu. Copy the newly created API key.

# Creating an SMS77 integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations?utm_campaign=docs-sms-sms77) page on Novu.
* Click the "Add a provider" button.
* Locate **SMS77** under the SMS section and click on the **Connect** button.
* Enter the `API key`.
* Click on the `Disabled` button and mark it as `Active`.
* Click on the **Save** button.
* Now it is possible to send SMS notifications using **SMS77** in Novu.


# Telnyx
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/telnyx

Learn how to use the Telnyx provider to send sms notifications using Novu

You can use the [Telnyx](https://telnyx.com/) provider to send transactional emails to your customers using the Novu Platform with a single API to create multi-channel experiences.

# Getting Started

To use the Telnyx provider in the SMS channel, you will need to create a Telnyx account and add your API key to the Telnyx integration on the Novu platform.

# Finding the API Key

To find your Telnyx API key:

* Log into your Telnyx account.
* Navigate to Account Setting.
* Then go to [Keys & Credentials](https://portal.telnyx.com/#/app/api-keys).
* You can copy the API key from there.
* Alternatively, you can create an API key by tapping on the Create API Key button.

Before copying it, make sure its status is showing active.

# Finding the Message Profile ID

To get your Message profile ID:

* Navigate to [Messaging](https://portal.telnyx.com/#/app/messaging) to find the profiles.
* Make sure you created a Telnyx Messaging Profile previously. Learn more [here](https://developers.telnyx.com/docs/v2/messaging/quickstarts/portal-setup).
* Go to the active Messaging Profile.
* Copy the profile ID.

# Making sure that the From address is valid

A valid from address must be a valid phone number in +E.164 format, a short code, or an alphanumeric sender ID associated with the sending messaging profile. Alphanumeric sender IDs must be between 1 and 11 characters long, and can only contain ASCII letters, numbers, and spaces. They must contain at least one letter.

# Creating a Telnyx integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations) page on the Novu.
* Click the "Add a provider" button.
* Locate Telnyx and click on the **Connect** button.
* Enter your Telnyx API Key.
* Fill in the Message profile ID field.
* Enter the Valid From address.
* Click on the `Disabled` button and `mark it as Active`.
* Click on the **Save** button.
* You should now be able to send notifications using Telnyx in Novu.


# Termii
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/termii

Learn how to use the Termii provider to send sms notifications using Novu

You can use the [Termii](https://termii.com/) provider to send SMS messages to your customers using the Novu Platform with a single API to create multi-channel experiences.

## Getting Started

To use the Termii provider in the SMS channel, the first step is to create a Termii account and add your API key and Sender ID to the Termii integration on the Novu platform.

## Retrieving your API Key

To find your Termii API key:

* [Sign up](https://accounts.termii.com/#/register) or [Login](https://accounts.termii.com/#/login) to your Termii account.
* Navigate to your [dashboard](https://accounts.termii.com/#/).
* Then scroll to the bottom of the page to find your API key.

<Frame>
  <img />
</Frame>

Alternatively, you can find the API key on the Settings page.

* Scroll to the bottom of the sidebar (on the left) and click on settings.
* This will display a dropdown from which you can then click on `API Token` to view your API key.

<Frame>
  <img />
</Frame>

## Getting your Sender's ID

Sender IDs allow you to brand your messages as you send them to your customers.

To get your Sender's ID:

* On the sidebar (on the menu on your left), click on `Rental`. This will display a dropdown. Click on `SMS Sender IDs` from the dropdown options.
* On the page that appears, you'll find a list of your Sender IDs

<Frame>
  <img />
</Frame>

If you have not created one yet:

* Click on the `Make a new request` button to request a Sender ID.
* Fill in the form
* Click on `Save`

<Frame>
  <img />
</Frame>

## Creating a Termii integration with Novu

* Visit the [Integrations](https://web.novu.co/integrations) page on Novu.
* Click the "Add a provider" button.
* Locate **Termii** under the SMS section and click on the **Connect** button.
* Enter your Termii API Key.
* Fill in the `From` field.
* Click on the Disabled button and mark it as Active.
* Click on the **Connect** button.

Now it is possible to send SMS notifications using **Termii** in Novu.


# Twilio
Source: https://v0.x-docs.novu.co/channels-and-providers/sms/twilio

Learn how to use the Twilio provider to send sms notifications using Novu

You can utilize the [Twilio](https://www.twilio.com/) API to communicate with your customers using SMS messaging. Let’s look at how you can do that:

# Setting up Twilio

1. First, go to [Twilio](https://www.twilio.com/) and create an account, probably starting with their free trial.
2. You’ll be asked to verify your email and your phone number. Get them verified.
3. Once you’re done with that, you’ll get an option to ‘get a Twilio phone number’ from your Twilio console.
4. Click on it to get your Twilio phone number.

When first using Twilio there should be an option to get a Twilio phone number in the main console. Otherwise, you may have to [Buy](https://console.twilio.com/us1/develop/phone-numbers/manage/search?frameUrl=%2Fconsole%2Fphone-numbers%2Fsearch%3Fx-target-region%3Dus1\&currentFrameUrl=%2Fconsole%2Fphone-numbers%2Fsearch%3FisoCountry%3DUS%26searchTerm%3D%26searchFilter%3Dleft%26searchType%3Dnumber%26x-target-region%3Dus1%26__override_layout__%3Dembed%26bifrost%3Dtrue) a number from that link to begin using it. Assuming this is the first run though, utilize the free number given to us.

Simply follow one of their many [Tutorials](https://www.twilio.com/docs/usage/requests-to-twilio) within their docs to understand every part of the process.

Irrespective of the language you use, the process is the same:

* Load the Account SID and Auth token into the code, using some sort of safe environment such as .env variables. Nobody should have access to this but you.
* Create a client object from Twilio that take the SID and Token as variables then create a message with the client.
* A message is an object that has three things:
  * that free number from earlier,
  * the number you would like to send to, and
  * a body message that you want to send through SMS.

# Creating a Twilio integration with Novu

Creating a Twilio integration with Novu is quite simple. Just follow these steps:

* Visit the [Integrations Store](https://web.novu.co/integrations) on Novu.
* Click the "Add a provider" button.
* Locate **Twilio** and click on the `Disabled` button and mark it as `Active`.
* Click on the **Connect** button.
* Go to your [Console](https://console.twilio.com/) on Twilio and access the Account Info section at the bottom of the page
* Enter your `Account SID`, `Auth Token` and `Twilio Phone Number`.
* Click on the **Save** button.
* You should now be able to send SMS notifications using **Twilio** in Novu.

## Sending an WhatsApp message with Twillio

To send a WhatsApps message with Twillio integration prefix the phone number of the subscriber with `whatsapp:` as shown below.

```ts theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
  {
    to: {
      subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
      phone: 'whatsapp:555-4242'
    },
  }
);
```

Read more about [sending a Message with the Twilio API for WhatsApp](https://www.twilio.com/docs/whatsapp/tutorial).


# Changelog
Source: https://v0.x-docs.novu.co/community/changelog

See the most recent changes and learn about how to shape Novu's future

<Card title="Novu's Changelog" icon="map" href="https://github.com/novuhq/novu/releases/">
  Learn about what's changed, new features, bug fixes, and see Novu's history across versions.
</Card>

Using the changelog, you can:

* Keep an eye on the latest updates,
* Learn more about the newly added features and improvements, and
* Stay informed about bug fixes and enhancement

## Getting involved:

Community is at the heart of everything we do at Novu. To get more involved with the community, you can:

* **Fork and Contribute** to our open issues as well as suggest new ideas at our [github repository](https://github.com/novuhq/novu)
* **Join our community** to ask questions, engage with other users and share ideas. Here's the [joining link.](https://discord.gg/novu?ref=docs-join-our-community)
* **Participate in our office hours** to learn more and connect with our core team. Join us [here.](https://www.youtube.com/@novuhq/streams)

<Tip>
  Remember, we're not building just another product, but a community of passionate developers who shape its evolution. Our changelog isn't just a list of updates but a reflection of our journey together. Your voice matters, and your ideas and feedback are what fuel our progress and shape our future. So, join us in this adventure, and – Let's build something amazing, one feature at a time!
</Tip>


# Novu Community Code of conduct
Source: https://v0.x-docs.novu.co/community/code-of-conduct

The set of rules and guidelines that govern interaction among community members

As a community-driven company, Novu is committed to creating an inclusive and welcoming environment for all members, regardless of factors such as age, body size, disability, ethnicity, gender identity, experience level, education, socio-economic status, nationality, personal appearance, race, religion, or sexual orientation.

However, diverse communities may face challenges, such as potential misunderstandings and miscommunications. To ensure respectful interactions, free from behaviour that may create an unsafe environment, we have established this Code of Conduct.

These guidelines do not cover every possible scenario comprehensively but serve as a guiding light towards courteous interactions among community members, aligning with the overarching principle of avoiding unprofessional behaviour. This Code of Conduct applies to all events and participants, aiming to maintain a welcoming and healthy environment for our community.

Traits of a Novu community member include:

### Being considerate and using appropriate channels

Contributions of every kind have far-ranging consequences. Just as your work depends on the work of others, decisions you make surrounding your contributions to the Novu community will affect your fellow community members. Use appropriate channels for what you’re about to say and refrain from tagging a role that sends out a lot of pings. You are strongly encouraged to take those consequences into account while making decisions.

### Adhering to these standards

It's crucial to keep in mind that our community members are from all kinds of backgrounds, so the members are expected to:

* Demonstrate empathy and kindness toward other people
* Be respectful of differing opinions, viewpoints, and experiences
* Give and accept constructive feedback gracefully
* Accept responsibility and apologise to those affected by mistakes, and learn from such experiences
* Focus on what is best not just for us as individuals, but for the overall community!

### Patience

Our community thrives on the generosity of volunteered time. Questions, contributions, and support requests may embark on a time-travelling journey before finding their destination. Repeated "bumps" or persistent "reminders" don’t display patience and are looked down upon. Lastly, it is a bad practice to ask general questions to a specific person (in direct messages for example). Try to ask in public as much as you can, and patiently wait for the response

### Inclusivity, kindness and respectfulness

Please be courteous and respectful to fellow members. Avoid offensive comments related to age, body size, disability, ethnicity, gender identity, experience level, education, socio-economic status, nationality, personal appearance, race, religion, or sexual orientation.

Strictly prohibited are sexualized imagery, violence, intimidation, stalking, disruptions, sharing personal information without explicit permission, unwanted physical contact, and unwelcome sexual attention.

Use inclusive language respecting our community's diversity.

Avoid assumptions about others' backgrounds. Maintain a positive and professional demeanour, refraining from threatening or inappropriate behaviour.

**We have zero tolerance for discrimination**. Any form of discrimination, including harassment, will lead to immediate consequences, potentially expulsion.

### Inquisitive

***The only stupid question is the one that does not get asked***.

We encourage our users to ask early and ask often. Rather than asking whether you can ask a question (the answer is always yes!), instead, simply ask your question. You are encouraged to provide as many specifics as possible.

Code snippets in the form of images are bad practice. Instead, use text formatted as code (using backticks) on Discord or simply send a gist. Refrain from pasting multiple lines of code directly into the chat channels - instead use [gist.github.com](http://gist.github.com/) or another paste site to provide code snippets.

### Helpful

Novu welcomes users of all skill levels. We were all beginners once, and a supportive environment is essential for the community to thrive. While it can be repetitive to answer the same questions, members are expected to be courteous and helpful to everyone.

Avoid sarcastic responses and prioritize useful information. Everyone should read the provided documentation. We're here to answer questions, offer guidance, and suggest workflows, but not to do your job for you.

### Anti-harassment policy

Harassment includes (but is not limited to) all of the following behaviors:

* Offensive comments related to gender (including gender expression and identity), age, sexual orientation, disability, physical appearance, body size, race, and religion.
* Derogatory terminology including words commonly known to be slurs
* Posting sexualized images or imagery in public spaces
* Deliberate intimidation
* Stalking
* Posting others’ personal information without explicit permission
* Sustained disruption of talks or other events
* Inappropriate physical contact
* Unwelcome sexual attention

Immediate compliance is expected from participants asked to cease harassing behaviour. Sponsors must adhere to the anti-harassment policy, refraining from using sexualized images or creating a sexualized environment at events. Volunteer organizers, including meetup staff, should also avoid sexualized attire.

Continuing inappropriate behaviour after being asked to stop constitutes harassment, even if not explicitly mentioned in this policy. It is respectful to stop doing something when asked to do so, and all community members are expected to promptly comply with such requests.

### Reporting policy violations

Instances of abusive, harassing, or otherwise unacceptable behaviour may be reported to anyone with administrative power in the community (Admins or Moderators on Discord, members of the ‘DevRel’ role), or to the local organizers of an event or to [support@novu.co](mailto:support@novu.co). Meetup organizers are encouraged to prominently display points of contact for reporting unacceptable behaviour at local events.

If a participant engages in harassing behaviour, the meetup organizers may take any action they deem appropriate. These actions may include but are not limited to warning the offender, expelling the offender from the event, and barring the offender from future community events.

Organizers will be happy to help participants contact security or local law enforcement, provide escorts to an alternate location, or otherwise assist those experiencing harassment to feel safe during the meetup. We value the safety and well-being of our community members and want everyone to feel welcome at our events, both online and offline.

We expect all participants, organizers, speakers, and attendees to follow these policies at all of our event venues and event-related social events.

### Enforcement Guidelines

Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:

1. **Correction**

* `Community Impact`: Use of inappropriate language or other behaviour deemed unprofessional or unwelcome in the community.
* `Consequence`: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behaviour was inappropriate. A public apology may be requested.

2. **Warning**

* `Community Impact`: A violation through a single incident or series of actions.
* `Consequence`: A warning with consequences for continued behaviour. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.

3. **Temporary Ban**

* `Community Impact`: A serious violation of community standards, including sustained inappropriate behaviour.
* `Consequence`: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.

4. **Permanent Ban**

* `Community Impact`: Demonstrating a pattern of violation of community standards, including sustained inappropriate behaviour, harassment of an individual, or aggression toward or disparagement of classes of individuals.
* `Consequence`: A permanent ban from any sort of public interaction within the community.

The Novu Community Code of Conduct is licensed under the Creative Commons Attribution-Share Alike 3.0 license.

Our Code of Conduct was adapted from Codes of Conduct of other open-source projects, including:

* **Contributor Covenant**
* **Elastic**
* **The Fedora Project**
* **OpenStack**
* **Ansible**
* **Puppet Labs**
* **Ubuntu**

Community Impact Guidelines were inspired by Mozilla's code of conduct enforcement ladder.

For answers to common questions about this code of conduct, see the FAQ at [https://www.contributor-covenant.org/faq](https://www.contributor-covenant.org/faq).

Translations are available at [https://www.contributor-covenant.org/translations](https://www.contributor-covenant.org/translations).


# Feature Flags
Source: https://v0.x-docs.novu.co/community/feature-flags

Learn how to enable/disable specific features in Novu

Feature flags allow to turn certain functionality on and off based on configuration. In this way, users can preview beta features in their deployments.

To enable the specific feature, you need to pass an environment variable to all services:

<Note>
  Feature flag environment variable accepts boolean values: `true` or `false`.
</Note>

* `IS_MULTI_PROVIDER_CONFIGURATION_ENABLED` adds ability to connect multiple providers per channel and make them active. It also shows redesigned integrations store page.

<Frame>
  <img />
</Frame>

* `IS_MULTI_TENANCY_ENABLED` adds ability to manage tenants from dashboard.

<Frame>
  <img />
</Frame>

* `IS_TEMPLATE_STORE_ENABLED` enables template store which contains pre-made workflows for common use cases (like **Password Reset** workflow etc).

<Frame>
  <img />
</Frame>


# Get involved with the Novu Community
Source: https://v0.x-docs.novu.co/community/get-involved

Your guide for engaging with the Novu Community

## Our Community

At Novu, we're a vibrant, open-source community driven by passion, collaboration, and a shared love for pushing boundaries. We believe in the power of community-driven development, where every voice matters and every contribution counts. As such, contributions are at the heart of how we evolve and progress forward.

## Join the conversation

* Read our [code of conduct](/community/code-of-conduct)
* Say “Hi!” in our [Discord Server](https://discord.gg/novu?ref=docs-community-introduction)
* Explore our [open issues](https://github.com/novuhq/novu/issues)
* Subscribe to our newsletter [to stay in the know](https://novu.co/novu-community-2-0/?utm_campaign=docs-comm2-get-involved)

## Getting help

Our fellow community members are always ready to help you get past a blocker. However, you can take a few things into consideration to help them help you:

* Share as many details as you can share. It will help us in debugging the issue.
* If there is any bug, please share steps to reproduce that bug.
* If there is any issue in running Novu on a local machine, please share system details like operating system, RAM size, npm version and node version.
* If there is any issue in our backend SDKs, please mention the SDK version and relevant details.
* If looking for self-hosting support, please share `Novu Version` and remote server details. Our latest version is `0.24.0`. Please be patient with self-hosting help. We are a small team and we will try our best to help you.

<Tip>Intercome is suitable if you're using Novu cloud or. Kindly use Discord or Github for community self-hosting questions.</Tip>

## Contributing

All community members are of one of the following four types:

1. Open source users
2. Active member
3. Power member
4. Novu Ambassador

### Become an active community member

* Everyone who joins our community becomes an open-source user automatically.
* You can become an active community member by:
  * Submitting >2 PRs
  * Opening >2 issues
  * Sending >5 messages on Github
  * Commenting >3 times on Github
* Active community members are one step closer to becoming Power community members and then an active moderator.

### Become a power community member

* All active community members are eligible to become a power community member and can become so by having at least one of the following:
  * Submitting 3 PRs
  * Opening 3 Issues
  * Sending 10 Discord messages
  * Commenting >10 times on Github
* Power community members are just one step away from becoming a Novu ambassador.

### Become a Novu Ambassador

A Novu ambassador is a trusted power member of the community that can do the following:

* Love exploring and sharing their knowledge of any technology with other developers.
* Often write and speak about Novu.
* Possess strong Novu expertise and often help and support Novu users within the community.
* Socially influence developers with some knowledge of Novu.
* Consistently contribute to Novu OSS product.

We are launching the Novu Ambassador program soon with amazing perks. Stay tuned!

## Activities

Are you passionate about notifications like we are? There are many different—and easy—ways to get involved.

### Help in onboarding and answering questions.

* Welcome new users into the community
* Answer questions in the [community support channel](https://discord.com/channels/895029566685462578/1019663407915483176).
* Offer input and opinions about various solutions you have tried.

### Improve our documentation

* Check out our[GitHub repo](https://github.com/novuhq/docs)
* No documentation is perfect, and neither is ours
* Help us improve our docs by
  * Updating outdated examples
  * Correcting typos and language for clarity
  * Find and fix broken links, etc.

### Help with the SDKs

* Link to contributors guide([https://github.com/novuhq/novu/blob/next/CONTRIBUTING.md](https://github.com/novuhq/novu/blob/next/CONTRIBUTING.md))
* We have SDKs in various languages and frameworks, most written and maintained by community members.
* You can either become a maintainer there or help the existing maintainers by bringing the SDK up to speed with the latest features present in the core product.
  * We have backend SDKs in the following: [Node.js](https://github.com/novuhq/novu/tree/next/packages/node), [PHP](https://github.com/novuhq/novu-php), [.NET](https://github.com/novuhq/novu-dotnet), [Elixir](https://github.com/novuhq/novu-elixir), [Go](https://github.com/novuhq/go-novu), [Ruby](https://github.com/novuhq/novu-ruby), [Python](https://github.com/novuhq/novu-python) [Laravel](https://github.com/novuhq/novu-laravel), and [Kotlin](https://github.com/novuhq/novu-kotlin)
  * And client-side SDKs in the follwing: [Vue](https://github.com/novuhq/novu/tree/next/packages/notification-center-vue), [React](https://github.com/novuhq/novu/tree/next/packages/notification-center), [Angular](https://github.com/novuhq/novu/tree/next/packages/notification-center-angular), [Web Component](https://github.com/novuhq/novu/tree/next/packages/notification-center), [iframe embed](https://docs.novu.co/notification-center/client/iframe), and [Headless Javascript.](https://docs.novu.co/notification-center/client/headless/get-started)

### Create content

* Content writers program: Apply to become a content writer with us and get paid to write about use-cases highlighting how you solved a problem using Novu
* Write an article about what you built with Novu and share it with the community. We’ll give you a shout out!

### PRs, issues, and bug reports

* Check out our [contributors guide](https://github.com/novuhq/novu/blob/next/CONTRIBUTING.md)
* Once you’ve gone through our [development process](https://docs.novu.co/community/run-in-local-machine), you can contribute directly to open issues.
* Open a new issue if a relevant one isn’t already open.
* Also, you can create bug reports if you find a bug somewhere.
* Or a feature request if you find something that should be a feature but isn't.

<Info>
  At Novu, we believe that no contribution is small, and the only wrong question is the one that doesn’t get asked. So feel free to ask any question or raise that Pull Request. You’re always welcome here! 🤗
</Info>

### Participate in office hours

* We have frequent (replace with interval— twice weekly, weekly, etc.) and topic-specific office hours that offer the ability to engage in real-time with Novu staff and other community members
* In these sessions, offer input, opinions, examples, etc. to contribute!

We’re excited to have you on board and look forward to your valuable contributions!

Together, we’ll shape the future of Novu. 🫂


# MacOS/Linux
Source: https://v0.x-docs.novu.co/community/machine-setup

Learn how to configure your local machine to run Novu

## Terminal upgrade (Optional)

### Install ZSH

ZSH is a shell on steroids, it has multiple plugins and functionality that can save a lot of time.

To install zsh run in your command line:

```shell theme={null}
sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
```

<Note>
  If you previously haven’t installed git on the machine, a prompt to install
  git will show up. After installation, run the `sh` command from above again.
</Note>

<Note>
  Make sure you have a `~/.zshrc` exists, if not it might be an indicator that
  the installation failed for some reason.
</Note>

### ZSH auto-complete plugin

Add the autocomplete plugin for autocompleting previously typed commands in the shell. Follow the instructions [here](https://github.com/zsh-users/zsh-autosuggestions/blob/master/INSTALL.md#oh-my-zsh).

### Powerlevel10k (optional)

[Powerlevel10k](https://github.com/romkatv/powerlevel10k) is a theme for Zsh. It emphasizes [speed](https://github.com/romkatv/powerlevel10k#uncompromising-performance), [flexibility](https://github.com/romkatv/powerlevel10k#extremely-customizable), and [out-of-the-box experience](https://github.com/romkatv/powerlevel10k#configuration-wizard).

1. Clone the repository:

   `git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k`

2. Set `ZSH_THEME="powerlevel10k/powerlevel10k"` in `~/.zshrc`.

3. Restart your terminal and follow the onboarding wizard to configure it to your likings and preferences.

## Command Line Tools, Homebrew & Casks

Every developer utilizes *Command Line Tools*. A simple terminal command will allow you to download these. It will ask you to confirm after you have entered the command.

```shell theme={null}
xcode-select --install
```

### Homebrew & Casks

[Homebrew](https://brew.sh/), it’s the missing package manager for macOS, and quite powerful at that.

Copy and paste the following code into your terminal to install Homebrew.

```shell theme={null}
/bin/shell -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

It will ask you to enter 'Return' to confirm the installation.

<Note>
  After installation run, the `echo` and `eval` commands shown on screen to add
  brew to your shell executables
</Note>

## Setting up git

To set up git and create an access token for GitHub, suggested installing [GitHub Desktop](https://www.notion.so/Dev-Machine-Setup-98d274c80fa249b0b0be75b9a7a72acb?pvs=21) before.

## Helpful settings

Show hidden files in Finder: `cmd + shift + .` or in the terminal:

```shell theme={null}
defaults write com.apple.finder AppleShowAllFiles YES
```

## Development Environment

### Node & NVM

For installing node we suggest installing it using [NVM](https://github.com/nvm-sh/nvm) (Node Version Manager) for easily managing multiple node versions.

1. Install nvm on your machine.

```shell theme={null}
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | shell
```

<Note>
  Make sure that you have installed zsh previously, so NVM can automatically
  inject the executable to PATH in the .zshrc config file.
</Note>

2. After installing nvm and checking that it’s in the path by running `nvm --version` in your CLI. You can now install our node version:

<Note>
  After running the install script, if you get `nvm: command not found` or see
  no feedback from your terminal after you type `command -v nvm`, simply **close
  your current terminal, open a new terminal**, and try verifying again.
</Note>

3. Optional for M1 processors - Install Rosetta.

Rosetta enables a Mac with Apple silicon to use apps built for a Mac with an Intel processor.

```shell theme={null}
softwareupdate --install-rosetta
```

### PNPM

For package management, we use [PNPM](https://pnpm.io/) instead of npm or yarn to speed up our install times and space efficiency. To install pnpm globally run:

```shell theme={null}
npm install -g pnpm@8.9.0
```

### Docker

Follow the installation guide on [docker website](https://docs.docker.com/desktop/mac/install/) to install docker on your own machine. For ease of use, we suggest installing **Docker Desktop**.

### AWS CLI

Follow the instructions to install the AWS CLI so you can use it to create env later on, based on existing S3 buckets:

[Installing or updating the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

You should get something like this:

<Frame>
  <img alt="AWS CLI" />
</Frame>

If needed, see:

[Resolve "Unable to locate credentials" error in Amazon S3](https://aws.amazon.com/premiumsupport/knowledge-center/s3-locate-credentials-error/)

### Run LocalStack

This is needed only when you upload files (for example - an image) in the admin panel from your local environment.

LocalStack emulates cloud service that runs in a single container on your computer. So you can run your AWS applications on your local machine without connecting to the remote cloud provider.

1. Build a container and run it:

```shell theme={null}
docker run --rm -it -p 4566:4566 -p 4571:4571 localstack/localstack
```

2. Create local S3 buckets needed for the app:

   In **local** environment:

   ```shell theme={null}
   aws --endpoint-url=http://localhost:4566 s3 mb s3://novu-local
   ```

   In **test** environment:

   ```shell theme={null}
   aws --endpoint-url=http://localhost:4566 s3 mb s3://novu-test
   ```

3. Update cors:

   ```json theme={null}
   aws --endpoint-url=http://localhost:4566 s3api put-bucket-cors --bucket novu-local --cors-configuration file://cors.json
   ```

   ```json cors.json theme={null}
   {
     "CORSRules": [
       {
         "AllowedOrigins": ["*"],
         "AllowedHeaders": ["*"],
         "AllowedMethods": ["GET", "PUT", "POST", "DELETE"],
         "MaxAgeSeconds": 3000,
         "ExposeHeaders": ["x-amz-server-side-encryption"]
       }
     ]
   }
   ```

### MongoDB

After installing brew you can easily install the MongoDB community edition.

1. Tap the [MongoDB Homebrew Tap](https://github.com/mongodb/homebrew-brew) to download the official Homebrew formula for MongoDB and the Database Tools, by running the following command in your macOS Terminal:

```shell theme={null}
brew tap mongodb/brew
```

2. To install MongoDB, run the following command in your macOS Terminal application

   1. You might need to update the Command Line Tools to be compatible with Xcode - see

   [Sign in with your Apple ID](https://developer.apple.com/download/all/?q=Xcode)

```shell theme={null}
brew install mongodb-community@5.0
```

3. Run the service in the background and start automatically after restart.

```shell theme={null}
brew services start mongodb/brew/mongodb-community@5.0
```

### Redis

After installing homebrew run the redis installation

```shell theme={null}
brew install redis
```

After installation run the service to start on system start as well.

```shell theme={null}
brew services restart redis
```

### Local dev domain (Optional)

This will allow you to use [local.novu.co](http://local.novu.co) instead of [localhost](http://localhost) when accessing the service on your machine.

Open the `/etc/hosts` file:

```shell theme={null}
sudo nano /etc/hosts
```

And add the [local.novu.co](http://local.novu.co) domain

```shell theme={null}
127.0.0.1       local.novu.co
```

### Code Editor

Feel free to install your favorite code editor. We supply licenses for [WebStorm](https://www.notion.so/WebStorm-7570ab1037bf494d88d0f9b544ae3b79?pvs=21), or you can [Visual Studio Code](https://code.visualstudio.com/download) if you prefer it.

### Productivity tools

* GitHub Desktop (Optional)

GitHub Desktop simplifies the development workflow and interaction with Git. [Download](https://desktop.github.com/) the client from their website.

* Clean your Dock bar (Optional)

For better productivity and wellness, we suggest removing the not-used apps from LaunchBar. Don’t worry if you will remove most apps from there. You can always use the spotlight to open the apps you need. Clean workspace === Happy life :)
Right Click on the app icon > Options > Remove from Dock

<Frame>
  <img alt="Dock" />
</Frame>


# Roadmap
Source: https://v0.x-docs.novu.co/community/roadmap

Learn about our roadmap

<Card title="Novu's Roadmap" icon="map" href="https://roadmap.novu.co/roadmap">
  Learn about ongoing developments, upcoming plans, and items in our backlog..
</Card>

Your involvement in shaping the future of our notification infrastructure solution is highly encouraged.

## Get involved

**Submit Ideas:** If you have a new feature idea or an enhancement suggestion, don't hesitate to submit it through our [roadmap page](https://roadmap.novu.co/roadmap). Your creativity fuels our innovation!

**Upvote and Comment:** Review the existing feature requests and upvote the ones that resonate with you. Feel free to provide additional insights or use-cases through comments.

**Contribute:** If you're a developer, you can actively contribute to the development of the features in progress or even the backlog ones. [Join our community of contributors](https://discord.gg/novu?ref=docs-contribute) and help us bring these enhancements to life.

<Tip>Remember, this roadmap is a living document that evolves based on your input and the direction the community decides to take. Your voice matters, and we're excited to work together in building a robust notification infrastructure solution that meets everyone's needs.</Tip>


# Run Novu in local machine
Source: https://v0.x-docs.novu.co/community/run-in-local-machine

Prerequisites and steps to run Novu in local machine. Learn how to set up Novu on your local environment for testing and development.

[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/novuhq/novu)

### Requirements

* Node.js version v20.8.1
* MongoDB
* Redis
* **(Optional)** pnpm - Needed if you want to install new packages
* **(Optional)** localstack (required only in S3 related modules)

Need help installing the requirements? Read more [here](/community/machine-setup).

<Note>We recommend having at least 8GB of RAM to run Novu on a local machine as Novu has multiple services running together with external services like redis, mongodb etc.</Note>

<iframe />

### Setup the project

After installing the required services on your machine, you can clone and set up
your forked version of the project:

1. Clone the repository

<Tabs>
  <Tab title="Novu Org">
    ```shell theme={null}
    git clone https://github.com/novuhq/novu.git
    ```
  </Tab>

  <Tab title="Forked Repo">
    ```shell theme={null}
    git clone https://github.com/{YOUR_GITHUB_USER_NAME}/novu.git
    ```
  </Tab>
</Tabs>

2. Install all dependencies

```shell theme={null}
cd novu && npm run setup:project
```

3. Run the project

```shell theme={null}
npm run start
```

The `npm run start` will start the Jarvis CLI tool which allows you to run the whole project with ease. If you only want to run parts of the platform, you can use the following run commands from the root project:

* **start:dev** - Synonym to `npm run start`
* **start:web** - Only starts the web management platform
* **start:ws** - Only starts the WebSocket service for notification center updates
* **start:widget** - Starts the widget wrapper project that hosts the notification center inside an iframe
* **start:api** - Runs the API in watch mode
* **start:worker** - Runs the worker application in watch mode
* **start:dal** - Runs the Data Access Layer package in watch mode
* **start:shared** - Starts the watch mode for the shared client and API library
* **start:node** - Runs the `@novu/node` package in watch mode
* **start:notification-center** - Runs and builds the React package for the Novu notification center

<iframe />

<iframe />

### Set up your environment variables

If you have used Jarvis CLI tool from the previous step you don't need to setup the env variables as Jarvis will do that on the first run if setup wasn't done before.

The command `npm run setup:project` creates default environment variables that are required to run Novu in a development environment. However, if you want to test certain parts of Novu or run it in production mode, you need to change some of them. These are all the available environment variables:

<AccordionGroup>
  <Accordion title="API Backend">
    * `NODE_ENV` (default: local)The environment of the app. Possible values are: dev, test, production, ci, local
    * `S3_LOCAL_STACK`The AWS endpoint for the S3 Bucket required for storing various media
    * `S3_BUCKET_NAME`The name of the S3 Bucket
    * `S3_REGION`The AWS region of the S3 Bucket
    * `PORT`The port on which the API backend should listen on
    * `FRONT_BASE_URL`The base url on which your frontend is accessible for the user. (e.g. web.novu.co)
    * `DISABLE_USER_REGISTRATION` (default: false)If users should not be able to create new accounts. Possible values are: true, false
    * `REDIS_HOST`The domain / IP of your redis instance
    * `REDIS_PORT`The port of your redis instance
    * `REDIS_PASSWORD`Optional password of your redis instance
    * `REDIS_DB_INDEX`The Redis database index
    * `REDIS_CACHE_SERVICE_HOST`The domain / IP of your redis instance for caching
    * `REDIS_CACHE_SERVICE_PORT`The port of your redis instance for caching
    * `REDIS_CACHE_DB_INDEX`The Redis cache database index
    * `REDIS_CACHE_TTL`The Redis cache ttl
    * `REDIS_CACHE_PASSWORD`The Redis cache password
    * `REDIS_CACHE_CONNECTION_TIMEOUT`The Redis cache connection timeout
    * `REDIS_CACHE_KEEP_ALIVE`The Redis cache TCP keep alive on the socket timeout
    * `REDIS_CACHE_FAMILY`The Redis cache IP stack version
    * `REDIS_CACHE_KEY_PREFIX`The Redis cache prefix prepend to all keys
    * `REDIS_CACHE_SERVICE_TLS`The Redis cache TLS connection support
    * `IN_MEMORY_CLUSTER_MODE_ENABLED`The flag that enables the cluster mode. It might be Redis or ElastiCache cluster, depending on the env variables set for either service.
    * `ELASTICACHE_CLUSTER_SERVICE_HOST`ElastiCache cluster host
    * `ELASTICACHE_CLUSTER_SERVICE_PORT`ElastiCache cluster port
    * `REDIS_CLUSTER_SERVICE_HOST`Redis cluster host
    * `REDIS_CLUSTER_SERVICE_PORTS`Redis cluster ports
    * `REDIS_CLUSTER_DB_INDEX`Redis cluster database index
    * `REDIS_CLUSTER_TTL`Redis cluster ttl
    * `REDIS_CLUSTER_PASSWORD`Redis cluster password
    * `REDIS_CLUSTER_CONNECTION_TIMEOUT`Redis cluster connection timeout
    * `REDIS_CLUSTER_KEEP_ALIVE`Redis cluster TCP keep alive on the socket timeout
    * `REDIS_CLUSTER_FAMILY`Redis cluster IP stack version
    * `REDIS_CLUSTER_KEY_PREFIX`Redis cluster prefix prepend to all keys
    * `JWT_SECRET`The secret keybase which is used to encrypt / verify the tokens issued for authentication
    * `SENDGRID_API_KEY`The api key of the Sendgrid account used to send various emails
    * `MONGO_URL`The URL of your MongoDB instance
    * `MONGO_MAX_POOL_SIZE`The max pool size of the MongoDB connection
    * `NOVU_API_KEY`The api key of web.novu.co used to send various emails
    * `SENTRY_DSN`The DSN of sentry.io used to report errors happening in production
  </Accordion>

  <Accordion title="Worker">
    * `NODE_ENV` (default: local)The environment of the app. Possible values are: dev, test, production, ci, local
    * `PORT`The port on which the Worker app should listen on
    * `STORE_ENCRYPTION_KEY`The encryption key used to encrypt/decrypt provider credentials
    * `MAX_NOVU_INTEGRATION_MAIL_REQUESTS`The number of free emails that can be sent with the Novu email provider
    * `NOVU_EMAIL_INTEGRATION_API_KEY`The Novu email provider Sentry API key
    * `STORAGE_SERVICE`The storage service name: AWS, GCS, or AZURE
    * `S3_LOCAL_STACK`The LocalStack service URL
    * `S3_BUCKET_NAME`The name of the S3 Bucket
    * `S3_REGION`The AWS region of the S3 Bucket
    * `GCS_BUCKET_NAME`The name of the GCS Bucket
    * `AZURE_ACCOUNT_NAME`The name of the Azure account
    * `AZURE_ACCOUNT_KEY`The Azure account key
    * `AZURE_HOST_NAME`The Azure host name
    * `AZURE_CONTAINER_NAME`The Azure container name
    * `AWS_ACCESS_KEY_ID`The AWS access key
    * `AWS_SECRET_ACCESS_KEY`The AWS secret access key
    * `REDIS_HOST`The domain / IP of your redis instance
    * `REDIS_PORT`The port of your redis instance
    * `REDIS_PASSWORD`Optional password of your redis instance
    * `REDIS_DB_INDEX`The Redis database index
    * `REDIS_CACHE_SERVICE_HOST`The domain / IP of your redis instance for caching
    * `REDIS_CACHE_SERVICE_PORT`The port of your redis instance for caching
    * `REDIS_DB_INDEX`The Redis cache database index
    * `REDIS_CACHE_TTL`The Redis cache ttl
    * `REDIS_CACHE_PASSWORD`The Redis cache password
    * `REDIS_CACHE_CONNECTION_TIMEOUT`The Redis cache connection timeout
    * `REDIS_CACHE_KEEP_ALIVE`The Redis cache TCP keep alive on the socket timeout
    * `REDIS_CACHE_FAMILY`The Redis cache IP stack version
    * `REDIS_CACHE_KEY_PREFIX`The Redis cache prefix prepend to all keys
    * `REDIS_CACHE_SERVICE_TLS`The Redis cache TLS connection support
    * `IN_MEMORY_CLUSTER_MODE_ENABLED`The flag that enables the cluster mode. It might be Redis or ElastiCache cluster, depending on the env variables set for either service.
    * `ELASTICACHE_CLUSTER_SERVICE_HOST`ElastiCache cluster host
    * `ELASTICACHE_CLUSTER_SERVICE_PORT`ElastiCache cluster port
    * `REDIS_CLUSTER_SERVICE_HOST`Redis cluster host
    * `REDIS_CLUSTER_SERVICE_PORTS`Redis cluster ports
    * `REDIS_CLUSTER_DB_INDEX`Redis cluster database index
    * `REDIS_CLUSTER_TTL`Redis cluster ttl
    * `REDIS_CLUSTER_PASSWORD`Redis cluster password
    * `REDIS_CLUSTER_CONNECTION_TIMEOUT`Redis cluster connection timeout
    * `REDIS_CLUSTER_KEEP_ALIVE`Redis cluster TCP keep alive on the socket timeout
    * `REDIS_CLUSTER_FAMILY`Redis cluster IP stack version
    * `REDIS_CLUSTER_KEY_PREFIX`Redis cluster prefix prepend to all keys
    * `MONGO_URL`The URL of your MongoDB instance
    * `MONGO_MAX_POOL_SIZE`The max pool size of the MongoDB connection
    * `NEW_RELIC_APP_NAME`The New Relic app name
    * `NEW_RELIC_LICENSE_KEY`The New Relic license key
    * `SEGMENT_TOKEN`The Segment Analytics token
  </Accordion>

  <Accordion title="Web Client">
    * `REACT_APP_ENVIRONMENT` The environment of the app. Possible values are: dev, test, production, ci, local
    * `REACT_APP_API_URL` The base url on which your API backend would be accessible
    * `REACT_APP_WS_URL` The base url on which your WebSocket service would be accessible
    * `SKIP_PREFLIGHT_CHECK` (default: true)Solves a problem with React App dependency tree.

    <Warning>
      When configuring different than default values for the API and WebSocket URLs,
      in order for the Web app to apply the changes done to the `./env` file, it is
      needed to run the script `pnpm envsetup`. This will generate a file
      called `env-config.js` that will be copied inside of the `public` folder of
      the application. Its purpose is to inject in the `window._env_`object the
      chosen environment variables that manage the URLs the Web client will call to
      access to the API backend and the WebSocket service.
    </Warning>
  </Accordion>

  <Accordion title="Web Socket">
    * `NODE_ENV` (default: local)The environment of the app. Possible values are: dev, test, production, ci, local
    * `SENTRY_DSN`The DSN of sentry.io used to report errors happening in production
    * `REDIS_HOST`The domain / IP of your redis instance
    * `REDIS_PORT`The port of your redis instance
    * `REDIS_DB_INDEX`The database index of your redis instance
    * `REDIS_PASSWORD`Optional password of your redis instance
    * `JWT_SECRET`The secret keybase which is used to encrypt / verify the tokens issued for authentication
    * `MONGO_URL`The URL of your MongoDB instance
    * `MONGO_MAX_POOL_SIZE`The max pool size of the MongoDB connection
    * `PORT`The port on which the WebSocket service should listen on
  </Accordion>
</AccordionGroup>

### Running tests

After making changes, you can run the tests for the respective package using the appropriate CLI commands:

### API

To run the API tests, run the following command:

```shell theme={null}
npm run start:worker:test
npm run start:e2e:api
```

The tests create a new instance of Novu and a test db and run the tests against it. The test db is removed after all tests have finished running.

### Web

To run the front end tests for the web project using cypress you need to install localstack. The cypress tests perform E2E tests. To be able to perform E2E tests, you need to run the API service in the appropriate test environment.

Run the services in test env with the following commands:

```shell theme={null}
npm run start:web
npm run start:api:test
npm run start:worker:test
npm run start:ws:test
```

Run the cypress test suite with the following command:

```shell theme={null}
cd apps/web && npm run cypress:run
```

To open the cypress management window to debug tests, run the following commands:

```shell theme={null}
cd apps/web && npm run cypress:open
```

### Different ports used by the services

* **3000** - API
* **3002** - WebSocket Service
* **3003** - Webhook Service
* **3004** - Worker Service
* **4200** - Web Management UI
* **4701** - Iframe embed for notification center
* **4500** - Widget Service

### Testing providers

To run tests against the providers’ folder, you can use the `npm run test:providers` command.

### Local environment setup script (beta)

As an option in our script runner `Jarvis` we have made available an option to run [this script](https://github.com/novuhq/novu/blob/2f2abdcaaad8a7735e0a2d488607c3276c8975fd/scripts/dev-environment-setup.sh) that will automatically try to install all the dependencies needed to be able to run Novu locally, as the previous step of installing the project dependencies through `pnpm install`. When executing it inside `Jarvis`, you will need to have previously installed by yourself `git` and `node`, as we mentioned earlier on this page.

The script can be run on its own without any previous dependency installed, as it is prepared to execute the following tasks:

* Check the running OS in the local machine (currently only MacOSx and [GNU Linux](https://en.wikipedia.org/wiki/GNU/Linux_naming_controversy)supported)
* Install of OS dependencies (currently only MacOSx supported) -- MacOSx: It will execute the following tasks --- Will try to install or update [XCode](https://developer.apple.com/xcode/) (skippable step; though XCode installs `[git](https://git-scm.com/)` that is a required dependency for later) --- Will install [Rosetta](https://support.apple.com/en-gb/HT211861) for Apple CPUs --- Will set up some opinionated OS settings
* Will check if `[git](https://git-scm.com/)` is installed and if not will abort the operation
* Will make [ZSH](https://en.wikipedia.org/wiki/Z_shell) the default shell to be able to execute the next task
* Will (opinionatedly) install [Oh My Zsh!](https://ohmyz.sh/) (skippable task)
* Will (opinionatedly) install the [Homebrew](https://brew.sh/) package manager and will set up your local environment to execute it besides adding some casks
* Will (opinionatedly) install [NVM](https://github.com/nvm-sh/nvm) as a Node.js version manager
* Will install the required [Node.js](https://nodejs.org/en/) version to be able to [run Novu](https://github.com/novuhq/novu/blob/2f2abdcaaad8a7735e0a2d488607c3276c8975fd/package.json#L180)
* Will install [PNPM](https://pnpm.io/) as a package manager, required dependency for some of the tasks inside Novu's scripts
* Will install [Docker](https://www.docker.com/) as containerized application development tool
* Will install required databases [MongoDB](https://www.mongodb.com/) (Community version) and [Redis](https://redis.io/) through Homebrew
* Will install the [AWS CLI](https://aws.amazon.com/cli/) tool (not required to run Novu; it is a core maintainer used tool)
* Will create a local development domain `local.novu.co` in your local machine
* Will clone the Novu repository in your local machine (skippable step) to a selected folder `$HOME/Dev`

<Warning>
  This script has only been thoroughly tested in MacOSx. Little testing has been
  run in GNU Linux.
</Warning>

<Info>
  This script is not bullet-proof and some of the tasks have intertwined
  dependencies with each other. We have tried to make it as idempotent as
  possible but some loose knots will probably show because of conflicts between
  versions of the different dependencies. Please report to us any problem found
  and we will try to fix or assist though we do not have the resources to make
  it idempotent in every potential system and potential combinations
</Info>


# Windows
Source: https://v0.x-docs.novu.co/community/windows-machine-setup

Learn how to configure your local Windows machine to run Novu

## Setting up git

To set up git and create an access token for GitHub, suggested installing [GitHub Desktop](https://www.notion.so/Dev-Machine-Setup-98d274c80fa249b0b0be75b9a7a72acb?pvs=21) before.

## Development Environment

### Node & NVM

To easily manage multiple node versions you can use [NVM for Windows](https://github.com/coreybutler/nvm-windows) a (Node Version Manager alternative for Windows).

Download the .exe installation file for NVM for Windows [here](https://github.com/coreybutler/nvm-windows/releases).

After installing NVM for Windows, check that the installation is successfull and added to path by running `nvm -v` on a terminal.

<Note>
  After installing NVM, if you get `nvm: command not found` or see
  no feedback from your terminal after you type `nvm -v`, simply **close
  your current terminal, open a new terminal**, and try verifying again.
</Note>

Once nvm is installed and working you can install any version of Node using the syntax `nvm install vX.Y.Z` and to switch to a node version,
run `nvm use vX.Y.Z`. Novu requires node v20.8.1 or higher:

```shell theme={null}
nvm install v18.17.0
nvm use v18.17.0
```

### PNPM

For package management, we use [PNPM](https://pnpm.io/) instead of npm or yarn to speed up our install times and space efficiency. To install pnpm globally run:

```shell theme={null}
npm install -g pnpm
```

### MongoDB

for detailed instructions on installing MongoDB community edition on a Windows machine please refere to the MongoDB doc [here](https://www.mongodb.com/docs/manual/tutorial/install-mongodb-on-windows).

After installation, whether you have installed as a Windows service or just the binaries, ensure that the MongoDB instance is started before you proceed.

### Redis

To install Redis for local development you'll first need to enable WSL2 (Windows Subsystem for Linux). detailed instructions for installing
WSL can be found [here](https://learn.microsoft.com/en-us/windows/wsl/install)

If you have WSL installed and enabled, you can easily install Redis using the native procedure for the Linux distribution that you have installed.
for Ubuntu or Debian which is the default distro installed by WSL, use the following commands

1. First install `lsb-release`, `curl` and `gpg` if you do not already have them:

```shell theme={null}
sudo apt install lsb-release curl gpg
```

2. Add the repository to the apt index, update it, and then install:

```shell theme={null}
curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg

echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list

sudo apt-get update
sudo apt-get install redis
```

3. Lastly, start the Redis server like so:

```shell theme={null}
sudo service redis-server start
```

### Docker

Docker is not a requirement to run Novu on your local machine, but if you would prefer to use Docker, Follow the installation guide on [docker website](https://docs.docker.com/desktop/install/windows-install/) to install **Docker Desktop** on your Windows machine.

### AWS CLI

Follow the instructions to install the AWS CLI so you can use it to create env later on, based on existing S3 buckets:

[Installing or updating the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

You should get something like this:

<img alt="AWS CLI" />

If needed, see:

[Resolve "Unable to locate credentials" error in Amazon S3](https://aws.amazon.com/premiumsupport/knowledge-center/s3-locate-credentials-error/)

### Local dev domain (Optional)

This will allow you to use [local.novu.co](http://local.novu.co) instead of [localhost](http://localhost) when accessing the service on your machine.

Navigate to `C:\Windows\System32\drivers\etc` in the file explorer and open the `hosts` file with a text editor (like Notepad):

<Note>
  Note that this file can only be edited when running as an Administrator.
</Note>

And add the [local.novu.co](http://local.novu.co) domain and save.

```shell theme={null}
127.0.0.1       local.novu.co
```

### Code Editor

Feel free to install your favorite code editor. We supply licenses for [WebStorm](https://www.notion.so/WebStorm-7570ab1037bf494d88d0f9b544ae3b79?pvs=21), or you can [Visual Studio Code](https://code.visualstudio.com/download) if you prefer it.

### Productivity tools

* GitHub Desktop (Optional)

GitHub Desktop simplifies the development workflow and interaction with Git. [Download](https://desktop.github.com/) the client from their website.


# Brand
Source: https://v0.x-docs.novu.co/content-creation-design/brand



Through Novu's web dashboard, you have the power to effortlessly tailor your brand settings, streamlining the process of creating notifications. Customize key elements such as your logo, which will be seamlessly integrated into your email communications.

For those utilizing Novu's In-App notification center, the ability to configure the primary font and its corresponding color awaits you. This empowers you to craft an experience for your users that resonates with your unique brand identity.

<img />


# Handlebars & Helpers
Source: https://v0.x-docs.novu.co/content-creation-design/handlebars-helpers



# Handlebars

The Novu notification content editor relies on Handlebars.js to establish the logic and control flow of our workflows.
For a deeper comprehension of Handlebars.js, you can refer to its [documentation](https://handlebarsjs.com/guide/#what-is-handlebars).

This resource offers comprehensive insights into the utilization of Handlebars.js in crafting dynamic and adaptable notification content within the Novu platform.

| Helper          | Description                                                                     | Example                                                          | Output                                                |
| --------------- | ------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ----------------------------------------------------- |
| if              | Conditionally renders a block. Falsy values won't be rendered.                  | `{{#if author}}<h1>{{firstName}} {{lastName}}</h1>{{/if}}`       | Renders `<h1>Yehuda Katz</h1>` if `author` is truthy. |
| includeZero     | `includeZero=true` treats the conditional as not empty, handling 0 differently. | `{{#if 0 includeZero=true}}<h1>Does render</h1>{{/if}}`          | Renders `<h1>Does render</h1>` for 0.                 |
| Sub-Expressions | Create custom logic helpers and use them in sub-expressions.                    | `{{#if (isdefined value1)}}true{{else}}false{{/if}}`             | Renders `true` or `false` based on custom helper.     |
| unless          | Inverse of if helper. Renders a block if the expression is falsy.               | `{{#unless license}}<h3 class="warning">WARNING</h3>{{/unless}}` | Renders warning if `license` is falsy.                |
| each            | Iterate over a list. Use this to reference the iterated element.                | `{{#each people}}<li>{{this}}</li>{{/each}}`                     | Renders list items.                                   |
| with            | Change context for template parts.                                              | `{{#with person}}{{firstname}} {{lastname}}{{/with}}`            | Renders `firstname` and `lastname` from the context.  |
| Nested each     | Access iteration variables in nested each blocks.                               | `{{#each array}}{{@index}}: {{this}}{{/each}}`                   | Renders index and item in each iteration.             |
| Nested with     | Use with block parameters for clear code.                                       | See above example with nested with and complex template.         | Renders nested context values.                        |
|                 | You can use else section to handle empty values.                                | `{{#with city}}...{{else}}No city found{{/with}}`                | Handles empty context case.                           |

# Novu-specific helpers

| Handlebar Expression                       | Description                                                                                                                                                                                                                           |
| ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `{{dateFormat date 'EEEE, MMMM Do yyyy'}}` | You can format the date using the `dateFormat` function. Here, `date: '2020-01-01'` has been formatted into `Wednesday, January 1st 2020`.                                                                                            |
| `{{lowercase key}}`                        | This helps you use the `lowercase` handlebar helper function and turns the value of the specified key to its lowercase value. So, for `message: 'hEllo WORLD'`, if we write `{{lowercase message}}`, we'll end up with `hello world`. |
| `{{uppercase key}}`                        | This helps you use the `uppercase` handlebar helper function and turns the value of the specified key to its uppercase value. So, for `message: 'hello woRld'`, if we write `{{uppercase message}}`, we'll end up with `HELLO WORLD`. |
| `{{titlecase key}}`                        | This helps you use the `titlecase` handlebar helper function and turns the value of the specified key to its titlecase value. So, for `message: 'hEllo wOrLD'`, if we write `{{titlecase message}}`, we'll end up with `Hello World`. |

### groupBy

`groupBy` helper is used to group the items in an array based on a property.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    {{#each (groupBy names "name")}}
      <h1>{{key}}<h1>
      {{#each items}}
        <h3>{{age}}</h3>
      {{/each}}
    {{/each}}
    ```
  </Tab>

  <Tab title="Context">
    ```json theme={null}
    {
      "names": [
        {
          "name": "Name 1",
          "age": "30"
        },
        {
          "name": "Name 2",
          "age": "31"
        },
        {
          "name": "Name 1",
          "age": "32"
        }
      ]
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
    <h1>Name 1<h1>
    <h3>30</h3>
    <h3>32</h3>
    <h1>Name 2<h1>
    <h3>31</h3>
    ```
  </Tab>
</Tabs>

### equals

`equals` helper allows you to perform comparisons, both for boolean expressions and string comparisons.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    <!-- LOGIC -->
    {{#equals value1 value2}}
       <!-- Code to execute when value1 is equal to value2 -->
    {{else}}
       <!-- Code to execute when value1 is not equal to value2 -->
    {{/equals}}


    <!-- Example -->
    {{#equals 10 1}}
       <h2> 10 is equal to 1 </h2>
    {{else}}
       <h1> 10 is not equal to 1 </h1>
    {{/equals}}
    ```
  </Tab>

  <Tab title="Context">
    ```json theme={null}
    {
      "value1" : 10,
      "values2" : 1
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
       <h1> 10 is not equal to 1 </h1>
    ```
  </Tab>
</Tabs>

### numberFormat

`numberFormat` helper is used to format numbers with specified decimal length, thousands separator, and decimal separator.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    <div>{{numberFormat number decimalSep="," decimalLength="2" thousandsSep="|"}}</div>
    <div>{{numberFormat nonNumber decimalSep="," decimalLength="2" thousandsSep="|"}}</div>
    ```
  </Tab>

  <Tab title="Context">
    ```json theme={null}
    {
      "number": 1000000000,
      "nonNumber": "Not a number"
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
    <div>1|000|000|000,00</div>
    <div>Not a number</div>
    ```
  </Tab>
</Tabs>

### pluralize

The `pluralize` helper allows you to easily handle pluralization in your templates by providing different forms of a word depending on a variable value.

### Basic Usage

In its simplest form, the `pluralize` helper takes three arguments:

```
{{pluralize count singular plural}}
```

* `count`: The numeric value that determines whether the singular or plural form should be used.
* `singular`: The singular form of the word.
* `plural`: The plural form of the word.

#### Example

```
{{pluralize dog_count "dog" "dogs"}}
```

In this example, if `dog_count` is equal to 1, it will render "1 dog," and if it's greater than 1, it will render "dogs."

## Use Cases & Examples

### Handling Event Count Display with Excluded Individuals

In some cases, you may want to display the total count of certain events but exclude specific individuals who are already mentioned. For example, when using a phrase like "John and `{{step.total_count}}` people liked your photo," you may notice that the count is off by one because "John" is already mentioned.

To account for such scenarios, you can utilize the following approach:

```
{{#each step.events}}
  {{#if @first}}
    {{this.name}}
  {{else}}
    {{#if @last}}
      and {{@index}}
    {{/if}}
  {{/if}}
{{/each}}
followed you!
```

In this code, we iterate through the `step.events` array and conditionally display each name. If it's the first name in the list, it will be shown without "and." For subsequent names, we add "and" before the last name. This ensures that the count is not affected by names that are explicitly mentioned in the message.

By using this code, you can achieve a more accurate representation of the event count in your messages, even when some users are individually mentioned in the message text.

### Using array length as count

Array length be used as total number of item. For example, if paylod have fruits property of type array then its length can be used as total number of fruits.

<Tabs>
  <Tab title="Template">
    ```html theme={null}
    Total number of fruits is {{fruits.length}}.
    ```
  </Tab>

  <Tab title="Payload">
    ```json theme={null}
    {
      "fruits": [
        {
          "name": "Pine apple",
          "price": "10$"
        },
        {
          "name": "Apple",
          "age": "8$"
        },
        {
          "name": "Orange",
          "age": "5$"
        }
      ]
    }
    ```
  </Tab>

  <Tab title="Output">
    ```html theme={null}
    Total number of fruits is 3.
    ```
  </Tab>
</Tabs>

<Note> In a future release, we plan to replace handlebar helpers with an alternative solution. Please note that custom handlebars in the editor itself are not currently supported. If we are missing any handlebar helper that is blocking you to write template for use case, feel free to reach out to us in [discord](https://discord.gg/novu?ref=docs-handlebar-helper)</Note>


# Layouts
Source: https://v0.x-docs.novu.co/content-creation-design/layouts

Explore how to create and manage layouts in Novu

### Email Layouts

Novu allows the creation of layouts - a specific HTML design or structure to wrap content of email notifications. Layouts can be manipulated and assigned to new or existing workflows within the Novu platform, allowing users to create, manage, and assign these layouts to workflows, so they can be reused to structure the appearance of notifications sent through the platform.

By default, Novu will create a default layout and assign it as the organization's default layout. At any time, you can choose any of your layouts as the default for your organization. All new email templates will be assigned the default layout unless assigned a different one through the email editor.

#### Manage Layouts

You can find and manage your organization's layouts in `Brand -> Layouts`

<img />

#### Create and Edit Layouts

You can create new or edit existing layouts through the layout editor.

* You can create any html code to structure your layout.
* Set a layout as default for your organization. Notice there could only be one default layout at a time.
* Manage layout variables - set default values or required variables.

<img />

<Info> Layout content must include `{{{body}}}`, to indicate where the email editor content will be injected inside the layout. </Info>

#### Assign layout to workflow

To assign, choose a layout through the email editor. You can preview your layout combined with your email content through the `Preview` tab.

<img />

#### Override layout on trigger

To override your assigned layout during a trigger event, use the `layoutIdentifier` property.

The layout specified will be used for all emails in the context of that trigger event.

```ts theme={null}
import { Novu } from '@novu/node';

const novu = new Novu('<NOVU_API_KEY>');

novu.trigger('workflow-identifier', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {
    attachments: [
      {
        file: fs.readFileSync(__dirname + '/data/test.jpeg'),
        name: 'test.jpeg',
        mime: 'image/jpg',
      },
    ],
  },
  overrides: {
    layoutIdentifier: 'your-layout-identifier',
  },
});
```

<Note> The override layout on trigger functionality is only available on v0.19.0.</Note>

#### Using SDK

Novu SDK supports all layout functionalities:

#### Create a new layout

A new layout can be created with name, description, content, variables and an `isDefault` flag. Here, content param is html content with custom variables.

```tsx theme={null}
const name: string = "layout-name";
const description: string =
  "The description of the layout that will help other users to understand the goal it was created"; // Optional.
const content: string = "<EMAIL_LAYOUT>";
const variables: ITemplateVariable[] = []; // Optional. Will handle the placeholder variables inserted in the email layout (content).
const isDefault: boolean = true; // Optional. All layouts are created as non default if not stated otherwise.

const { _id: layoutId } = await novu.layouts.create({
  name,
  description,
  content,
  variables,
  isDefault,
});
```

```tsx theme={null}
interface ITemplateVariable {
  type: TemplateVariableTypeEnum;
  name: string;
  required?: boolean;
  defaultValue?: string | boolean;
}

enum TemplateVariableTypeEnum {
  STRING = "String",
  ARRAY = "Array",
  BOOLEAN = "Boolean",
}
```

#### Update existing layout

When updating a layout, all properties are optional and the SDK will only update the ones passed.

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout.

const updatedLayout = await novu.layouts.update(layoutId, {
  name,
  description,
  content,
  variables,
  isDefault,
});
```

#### Set default layout

When executing this, the existing default layout in the environment will be automatically set as non default and the chosen layout will be set as default. This action is non reversible.

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout to be set as default.

await novu.layouts.setDefault(layoutId);
```

#### Delete an existing layout

Layouts can also be deleted. The condition to be able to delete a layout is that it is not a default layout and is not assigned in any existing workflow.

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout to be deleted.

await novu.layouts.delete(layoutId);
```

#### Get a layout

Find a layout by layoutId

```tsx theme={null}
const layoutId: LayoutId = "<LAYOUT_ID>"; // The unique identifier of the layout to be found.

const layout = await novu.layouts.get(layoutId);
```

#### List all layouts

List paginated layouts

```tsx theme={null}
const page: number = 0; // Pagination value of the page for the results. First page will be page = 0.
const pageSize: number = 100; // Optional. Pagination value of the amount of layouts per page to return.
const sortBy: string = "createdAt"; // Optional. Property to order the list of the layouts. So far only `createdAt` is supported.
const orderBy: OrderDirectionEnum = -1; // Optional. Direction of the sorting by the property chosen in `sortBy`. Ascendent order is represented by 1 and descendent order is represented by -1.

const layouts = await novu.layouts.list({
  page,
  pageSize,
  sortBy,
  orderBy,
});
```

## API Reference Links

* [Layout Methods](/api-reference/layouts/layout-creation/)


# Content Creation
Source: https://v0.x-docs.novu.co/content-creation-design/notification-content-creation

Explore how to create notification content

To demonstrate the extensive range of possibilities, we've crafted a subscriber profile enriched with various attributes to highlight the flexibility of our system.

```typescript theme={null}
const subscriber = {
    subscriberId: '6427e97d0136cef86a315c46',
    firstName: 'John',
    lastName: 'Doe',
    email: 'john.doe@gmail.com',
    phone: '+98712345677',
    avatar: 'https://sm.ign.com/ign_nordic/cover/a/avatar-gen/avatar-generations_prsz.jpg',
    locale: 'en-US',
    data: {
        plan: 'basic',
        zipcode: 14925,
        validVehicleLicense: true
    }
};
```

Let's go over examples for each communication channel:

## Email

There are multiple ways to craft your email notification content for maximum impact.

<Note>
  Please remember that you have the option to preview the anticipated output of
  your input using the editor. Simply switch from the editing mode to the
  preview mode to see the results.
</Note>

### Regular Editor

Example: Send a personalized welcome email to a user by leveraging their properties.

**Input:**

```html theme={null}
Hello {{subscriber.firstName}} {{subscriber.lastName}}!

We are excited to welcome you to our {{subscriber.data.plan}} plan.
Look forward to receiving daily updates from us on your phone number: {{subscriber.phone}}.

{{#if subscriber.data.validVehicleLicense}}
Why not consider renting a car to visit us?
{{else}}
We're delighted to offer you a train ticket to come see us.
{{/if}}

Should you require any assistance, don't hesitate to reach out.
Best regards,
Your friends at Novu.
```

<img />

**Output:**

```html theme={null}
Hello John Doe!

We are excited to welcome you to our basic plan.
Look forward to receiving daily updates from us on your phone
number: +98712345677.

Why not consider renting a car to visit us?
Should you require any assistance, don't hesitate to reach out.
Best regards,
Your friends at Novu.
```

<img />

### Custom Code Editor

**Input:**

<Accordion title="Email Template Example">
  ```HTML theme={null}
  <!DOCTYPE html>
  <html>
  <head>
    <meta charset="UTF-8">
    <title>Welcome to Novu!</title>
    <style>
        /* Inline styles for email compatibility */
        body {
            font-family: 'Helvetica Neue', Arial, sans-serif;
            background-color: #f4f4f4;
            margin: 0;
            padding: 0;
        }
        .container {
            max-width: 600px;
            margin: 0 auto;
            padding: 20px;
            background-color: #ffffff;
            border-radius: 10px;
            box-shadow: 0 3px 6px rgba(0, 0, 0, 0.1);
        }
        .header {
            text-align: center;
            margin-bottom: 20px;
        }
        .message {
            font-size: 16px;
            line-height: 1.6;
            color: #333333;
            margin-bottom: 20px;
        }
        .cta-button {
            display: inline-block;
            padding: 10px 20px;
            background-color: #007bff;
            color: #ffffff;
            text-decoration: none;
            border-radius: 5px;
            font-weight: bold;
        }
        .signature {
            margin-top: 20px;
            font-style: italic;
            color: #888888;
        }
    </style>
  </head>
  <body>
    <div class="container">
        <div class="header">
            <h1 style="color: #007bff;">Welcome to Novu!</h1>
        </div>
        <div class="message">
            <p>Hello {{subscriber.firstName}} {{subscriber.lastName}}!</p>
            <p>We are thrilled to have you on board with our {{subscriber.data.plan}} plan.</p>
            <p>Get ready to receive daily updates on your phone: {{subscriber.phone}}.</p>
            <p>{{#if subscriber.data.validVehicleLicense}}
                We would like to offer you renting a car to visit us.
            {{else}}
                We would like to buy you a train ticket to visit us.
            {{/if}}</p>
            <p>If you need any assistance or have questions, feel free to reach out.</p>
            <p><a class="cta-button" href="#">Explore Your Options</a></p>
        </div>
        <div class="signature">
            <p>Best regards,<br>Your friends at Novu</p>
        </div>
    </div>
  </body>
  </html>
  ```
</Accordion>

<img />

**Output:**

<img />

<Info>Email Subject, Sender Name and Preheader field accepts system, payload variables and handlebar helpers</Info>
[Explore how to manage Email layouts.](/content-creation-design/layouts)

## In-App

The In-App notification content editor closely resembles the Email notification editor, although with some discernible differences.

<img />

You can:

* Transform notifications into clickable links, redirecting to your specified URLs
* Enjoy unlimited character freedom
* Utilize all variables to craft dynamic and personalized messages
* Infuse your brand's essence with customizable elements
* Drive engagement with action buttons
* Embed avatar images
* Preview the expected output

## SMS

When crafting your SMS notification, you can tap into all the available variables and even add dynamic ones.

<img />

## Chat

We make it effortless to send notifications to chat providers like Slack, Microsoft Teams, and Discord. Meet your users in the tools they use daily.
You have the ability to utilize all variables to craft dynamic and personalized messages.

<img />

## Push

Push channel has two fields `Push Message Title` and `Push Message Content` where user can write hard coded text content or use system, dynamic variables or handlebar helpers to customize notification content.

<img />


# Translations
Source: https://v0.x-docs.novu.co/content-creation-design/translations

Translate notification content to different languages using i18n.

<Info>The feature is only available for **Novu Cloud** users with **Business** or **Enterprise** plans.</Info>

## Introduction

The Translation Management feature allows you to seamlessly adapt your workflows to different languages and automatically apply them based on your customers' locales. It enhances engagement, personalizes the user experience, and allows you to expand your market reach.

To understand how Translation Management works in Novu we need to review its main pillars:

* Translation Groups
* Translation Files
* Localized Message Content
* Subscribers locale

## Translation Groups

Translation Group allows you to efficiently manage translations for diverse languages with shared business significance. For example, the Branding translation group can hold the content related to your company identity, while the Marketing translation group can exclusively house content related to your marketing campaigns. You aren't obligated to divide your translation content, you can manage it all within a single translation group.

To create the Translation Group navigate to the `Translations` page from the main navigation and click on the “Add group” button.

<img />

Before creating your first Translation Group you'll be prompted to specify the default locale for organization. This locale serves as a fallback option for localized messages in cases where the recipient hasn't defined a specific locale.

<img />

After selecting the default language, you can provide the essential details: the group name, group identifier, and select your target languages.

The group identifier is an important value that you will later use in the editor to localize your messages. This is a similar concept that we use across the app to identify the main parts.

<img />

After the group is created, you will land on the group details page on which you can see the list with the empty translations for the languages you choose.

<img />

## Translations

Translations are JSON files that contain the content of your messages in a specific language. For example, if you created a Marketing translation group with two target languages English and German, then your translation JSON files might look like this:

**English (en.json):**

```json theme={null}
{
  "welcome_message": "Welcome to our Marketing Campaign!",
  "learn_more": "Learn More",
  "special_offer": "Special Offer",
  "contact_us": "Contact Us"
}
```

**German (de.json):**

```json theme={null}
{
  "welcome_message": "Willkommen bei unserer Marketingkampagne!",
  "learn_more": "Mehr erfahren",
  "special_offer": "Sonderangebot",
  "contact_us": "Kontaktieren Sie uns"
}
```

To upload your translations click on the “Upload files” button located at the top of the Translation Group details page.

<img />

Select the translation files and click “Open” button.

<img />

With each uploaded translation file, you must indicate the language it references. Additionally, you can verify the correctness of the uploaded file by previewing its contents.

<img />

Click on “Upload files” button. Congratulations you just uploaded the translation files and created the translation group! 🎉

### Localized Message Content

To localize your message content, you need to use the translation variables in the editor. The variables allow you to reference the values from the translation files. It consists of the `i18n` [handlebar](https://docs.novu.co/content-creation-design/handlebars-helpers) helper and path to the translated value.

Let’s take a look at the example: `{{i18n "marketing.welcome_message"}}`.

* `i18n` is the handlebar helper that tells Novu that you would like to use the Translations
* `"marketing.welcome_message"` is the path that is composed of the Translation Group identifier `marketing` and translation JSON file key `welcome_message`

<img />

<Info>i18n variables can be used in `subject` and `preheader` fields of the email step.</Info>

## Subscribers Locale

The subscribers locale defines in which language the message should be delivered to that recipient. When the locale is not specified it will fallback to the default locale set for the organization. The locale format includes ISO language plus the region, for example `de_DE` language German and region Germany.

To update the locale you can use Novu API or any of our SDKs, more information can be found [here](https://docs.novu.co/subscribers/subscribers).

## Editor Examples

### Variables

It is possible to include variables in your translation strings, they should be wrapped in double curly brackets. Their value could be set as a string or as a variable - either a system variable or a variable sent through the payload.

```json theme={null}
{
  "withVariables": "Welcome {{name}} to {{organization}}"
}
```

In the editor:

```handlebars theme={null}
{{i18n "welcome.withVariables" name=subscriber.firstName organization="Novu"}}
```

### Context

By providing a context you can differ translations. Eg. useful to provide gender specific translations.

For example:

```json theme={null}
{
	"friend": "A friend",
	"friend_male": "A boyfriend",
	"friend_female": "A girlfriend"
}
```

In the editor:

```handlebars theme={null}
{{i18n "welcome.friend" context="male"}}
```

Will result in the message `A boyfriend`. Not adding any context will output `A friend`.

### Plurals

To distinguish between plural translation options.

```json theme={null}
{
	"keyWithCount": "{{count}} item",
	"keyWithCount_plural": "{{count}} items",
}
```

In the editor:

```handlebars theme={null}
{{i18n "welcome.keyWithCount" count=7}}
```

Will result in `7 items`

### Date formats

To control date formats, do as follows:

```json theme={null}
{
  "date": "Current date: {{date, dd/MM/yyyy}}",
  "try_date": "Current date: {{date, MM/dd/yyyy}}",
  "intlDateTime": "On the {{date, HH:yyyy}}"
}
```

In the editor:

<Tip>
  Date can be a string or a variable you send in the payload as `{ date: new Date() }`
</Tip>

```handlebars theme={null}
{{i18n "welcome.date" date="12-06-2023"}}
{{i18n "welcome.try_date" date=date}}
{{i18n "welcome.intlDateTime" date=date}}
```


# Workflow Editor
Source: https://v0.x-docs.novu.co/content-creation-design/variables



Novu's content creation tools allow developers to utilize a wealth of variables when designing notification workflows.

As developers construct workflows using Novu, certain status facets—results of batch functions and other steps in the workflow—are auto-generated and can be utilized to control the content displayed in notification templates.

These variables offer dynamic and automated properties that hold subscriber information, such as first and last name, email, phone, and avatar.

For example, developers can insert a subscriber's first name into a workflow by using `{{ subscriber.firstName }}`.

In addition to the subscriber's details, developers can use data payload variables that encapsulate dynamic data meant to be injected into the content of a workflow.

For instance, in the code example the variables username and resetLink are data payload variables that would be adjusted based on the workflow's purpose.

**The utilization of these variables allows Novu to deliver personalized notifications to the receiver, thus improving user experience and accomplishing better communication outcomes.**

## System Variables

### Subscriber Variables

| Variable       | Type     | Description                                                                   |
| -------------- | -------- | ----------------------------------------------------------------------------- |
| `subscriber`   | `Object` | Represents someone who is intended to receive a notification.                 |
| `firstName`    | `String` | The first name of the subscriber.                                             |
| `lastName`     | `String` | The last name of the subscriber.                                              |
| `email`        | `String` | The subscriber's email address.                                               |
| `phone`        | `String` | The phone number associated with the subscriber.                              |
| `avatar`       | `String` | A URL or reference to the subscriber’s avatar or profile picture.             |
| `locale`       | `String` | The preferred locale or language of the subscriber.                           |
| `subscriberId` | `String` | Unique identifier for the subscriber.                                         |
| `data`         | `Object` | An additional object that can hold custom subscriber data as key-value pairs. |

### Actor Variables

| Variable       | Type     | Description                                                              |
| -------------- | -------- | ------------------------------------------------------------------------ |
| `actor`        | `Object` | A subscriber who initiates actions triggering events.                    |
| `firstName`    | `String` | The first name of the actor.                                             |
| `lastName`     | `String` | The last name of the actor.                                              |
| `email`        | `String` | The actor's email address.                                               |
| `phone`        | `String` | The phone number associated with the actor.                              |
| `avatar`       | `String` | A URL or reference to the actor’s avatar or profile picture.             |
| `locale`       | `String` | The preferred locale or language of the actor.                           |
| `subscriberId` | `String` | Unique identifier for the actor.                                         |
| `data`         | `Object` | An additional object that can hold custom actor data as key-value pairs. |

### Step Variables

| Variable      | Type      | Description                                                                 |
| ------------- | --------- | --------------------------------------------------------------------------- |
| `step`        | `Object`  | A component in the execution of a workflow.                                 |
| `digest`      | `Boolean` | Indicates whether digest mode is active or not.                             |
| `events`      | `Array`   | An aggregated collection of events (that are stored when digest is active). |
| `total_count` | `Number`  | Represents the total number of events in the digest.                        |

### Brand Variables

| Variable   | Type     | Description                                                                 |
| ---------- | -------- | --------------------------------------------------------------------------- |
| `branding` | `Object` | Enables customization of the notification's visual identity.                |
| `logo`     | `String` | Insert the brand logo.                                                      |
| `color`    | `String` | Set the primary color of the notification based on the brand configuration. |

### Tenant Variables

| Variable | Type     | Description                                                               |
| -------- | -------- | ------------------------------------------------------------------------- |
| `tenant` | `Object` | Group of users or an organization.                                        |
| `name`   | `String` | Insert the brand logo.                                                    |
| `data`   | `Object` | An additional object that can hold custom tenant data as key-value pairs. |

## Data Payload Variables

Data payload variables encompass the dynamic data intended to be injected into the content of a workflow. These variables are integral components of the payload object, forming part of the parameters for the trigger function.

Here's a more illustrative example of how data payload variables can be employed:

```jsx theme={null}
curl -L -X POST 'https://api.novu.co/v1/events/trigger' \
-H 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
-H 'Content-Type: application/json' \
--data-raw '{
    "name": "password-reset",
    "to": {
        "subscriberId": "6427e97d0136cef86a315c46",
        "email": "john.doe@acme.com"
    },
    "payload": {
        "username": "Jhontheman1969",
        "resetLink": "http://sample.info/password.reset",
        "securityEmail": "john.doe.backup@acme.com",
    }
}'
```

Within this code snippet, the variables `username` and `resetLink` are representative of data payload variables.

Importantly, it's worth noting that the payload itself can encompass any serializable JSON object.

<Info>Avoid use of system reserved variables as normal variables. For example don't use `email` as variable name because `{{subscriber.email}}` is a system reserved variable</Info>


# Backend SDK methods
Source: https://v0.x-docs.novu.co/notification-center/backend/methods



### Fetch subscriber’s In-App notifications feed

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: inAppMessages } = await novu.subscribers.getNotificationsFeed(
    "subscriberId",
    {
      page: 0,
      limit: 10,

      // it is of type string. By default all feeds messages are fetched
      feedIdentifier: "Product Updates",

      // seen and read filter of type boolean
      seen: true,
      read: true,
    }
  );
  ```
</CodeGroup>

### Fetch all Messages Sent To All Subscribers

<CodeGroup>
  ```javascript Node.JS theme={null}
  import { ChannelTypeEnum } from "@novu/node";

  // All fields are optional
  const listMessagesOptions = {
    // pagination options
    page: 0,
    limit: 20,

    /**
     *  Filter options
     */
    // use ChannelTypeEnum.PUSH for push, ChannelTypeEnum.EMAIL for email,
    channel: ChannelTypeEnum.IN_APP, // only In-App type messages will be fetched
    subscriberId: "6444105141ffb0919496dfcb",
    transactionIds: ["644-41051-41ffb0-919496-dfcb"],
  };

  const { data: messagesData } = await novu.messages.list(listMessagesOptions);
  ```
</CodeGroup>

### Delete an In-App notification/message

<CodeGroup>
  ```javascript Node.JS theme={null}
  // messageId is of MongoDB Id type
  await novu.messages.deleteById("messageId");
  ```
</CodeGroup>

### Mark an In-App Message as Read/Seen

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: markMessageAsRead } = await novu.subscribers.markMessageRead(
    "subscriberId",
    "messageId"
  );

  const { data: markMessageAsSeen } = await novu.subscribers.markMessageSeen(
    "subscriberId",
    "messageId"
  );
  ```
</CodeGroup>

### Mark an In-App Message as Read/Unread/Seen/Unseen

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: markMessageAs } = await novu.subscribers.markMessageAs(
    "subscriberId",
    "messageId",
    { seen: true, read: false }
  );
  ```
</CodeGroup>

### Mark all In-App Messages as Read/Unread/Seen/Unseen

<CodeGroup>
  ```javascript Node.JS theme={null}
  import { MarkMessagesAsEnum } from "@novu/node"

  const { data: markAllInAppMessages } = await novu.subscribers.markAllMessagesAs(
     'subscriberId',

     // can be filtered with feed identifiers
     feedIdentifier: ['Marketing', 'Product']

     // MarkMessageAsEnum.READ => It will mark all messages as read
     // MarkMessageAsEnum.SEEN => It will mark all messages as seen
     // MarkMessageAsEnum.UNREAD => It will mark all messages as unread
     // MarkMessageAsEnum.UNSEEN => It will mark all messages as unseen
     markAs: MarkMessageAsEnum.Read
  );
  ```
</CodeGroup>

### Fetch All Feeds

<CodeGroup>
  ```javascript Node.JS theme={null}
  const { data: feedsData } = await novu.feeds.get();
  ```
</CodeGroup>


# Angular Component
Source: https://v0.x-docs.novu.co/notification-center/client/angular



The `@novu/notification-center-angular` package provides an Angular component wrapper over the Notification Center Web Component that you can use to integrate the notification center into your Angular application.

## Installation

<Tip>Novu supports Angular version 15 and higher.</Tip>

<CodeGroup>
  ```bash pnpm theme={null}
  pnpm i @novu/notification-center-angular
  ```

  ```bash npm theme={null}
  npm i @novu/notification-center-angular
  ```

  ```bash yarn theme={null}
  yarn add @novu/notification-center-angular
  ```
</CodeGroup>

## Example usage

Module:

```tsx theme={null}
import { NotificationCenterModule } from '@novu/notification-center-angular';

@NgModule({
  imports: [..., NotificationCenterModule],
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
})
export class TheModule {}
```

Component:

```tsx theme={null}
import { Component } from "@angular/core";
import { environment } from "../environments/environment";

@Component({
  selector: "my-component",
  templateUrl: "./component.html",
})
export class AppComponent {
  subscriberId = environment.subscriberId;
  applicationIdentifier = environment.applicationIdentifier;

  sessionLoaded = (data: unknown) => {
    console.log("loaded", { data });
  };
}
```

Component HTML template:

```html theme={null}
<notification-center-component
  [subscriberId]="subscriberId"
  [applicationIdentifier]="applicationIdentifier"
  [sessionLoaded]="sessionLoaded"
></notification-center-component>
```

## Props

The `notification-center-component` accepts the same set of props as the [web component](/notification-center/client/web-component).

<Tip>
  You may need to add `"allowSyntheticDefaultImports": true` in tsconfig.json for the web component's React imports to work correctly.
</Tip>

## Example

* [Angular Notification Center Example Repo](https://github.com/novuhq/examples/tree/main/novu-angular-notification-center)
* [Example Source Code 🔗](https://github.com/novuhq/examples/tree/main/novu-angular-notification-center)


# Headless API Reference
Source: https://v0.x-docs.novu.co/notification-center/client/headless/api-reference



This page contains the complete documentation about the Headless Notification Center package. You can find here the list of all the methods that you can use.

## initializeSession

To use the headless service, you'll need to initialize the session first. This sets the token and starts the socket listener service.

```typescript theme={null}
headlessService.initializeSession({
  listener: (result: FetchResult<ISession>) => {
    console.log(result);
  },
  onSuccess: (session: ISession) => {
    console.log(session);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IInitializeSession {
  listener: (result: FetchResult<ISession>) => void;
  onSuccess?: (session: ISession) => void;
  onError?: (error: unknown) => void;
}
```

## fetchOrganization

Fetches the details of the current organization

```typescript theme={null}
headlessService.fetchOrganization({
  listener: (result: FetchResult<IOrganizationEntity>) => {
    console.log(result);
  },
  onSuccess: (organization: IOrganizationEntity) => {
    console.log(organization);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchOrganization {
  listener: (result: FetchResult<IOrganizationEntity>) => void;
  onSuccess?: (session: IOrganizationEntity) => void;
  onError?: (error: unknown) => void;
}
```

## fetchUnseenCount

Fetches the count of unseen messages

```typescript theme={null}
headlessService.fetchUnseenCount({
  listener: (result: FetchResult<{ count: number }>) => {
    console.log(result);
  },
  onSuccess: (data: { count: number }) => {
    console.log(data);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchUnseenCount {
  listener: (result: FetchResult<{ count: number }>) => void;
  onSuccess?: (data: { count: number }) => void;
  onError?: (error: unknown) => void;
}
```

## fetchUnreadCount

Fetches the count of unread messages

```typescript theme={null}
headlessService.fetchUnreadCount({
  listener: (result: FetchResult<{ count: number }>) => {
    console.log(result);
  },
  onSuccess: (data: { count: number }) => {
    console.log(data);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchUnreadCount {
  listener: (result: FetchResult<{ count: number }>) => void;
  onSuccess?: (data: { count: number }) => void;
  onError?: (error: unknown) => void;
}
```

## listenNotificationReceive

Listens to a new notification being added. Can be used to retrieve a new notification in real-time and trigger UI changes.

```typescript theme={null}
headlessService.listenNotificationReceive({
  listener: (message: IMessage) => {
    console.log(JSON.stringify(message));
  },
});
```

### method args interface

```typescript theme={null}
interface IListenNotificationReceive {
  listener: (message: IMessage) => void;
}
```

## listenUnseenCountChange

Listens to the changes of the unseen count. Can be used to get real time count of the unseen messages.

```typescript theme={null}
headlessService.listenUnseenCountChange({
  listener: (unseenCount: number) => {
    console.log(unseenCount);
  },
});
```

### method args interface

```typescript theme={null}
interface IListenUnseenCountChanget {
  listener: (unseenCount: number) => void;
}
```

## listenUnreadCountChange

Listens to the changes of the unread count. Can be used to get real time count of the unread messages.

```typescript theme={null}
headlessService.listenUnreadCountChange({
  listener: (unreadCount: number) => {
    console.log(unreadCount);
  },
});
```

### method args interface

```typescript theme={null}
interface IListenUnreadCountChanget {
  listener: (unreadCount: number) => void;
}
```

## fetchNotifications

Retrieves the list of notifications for the subscriber. Can also be used to get the notifications of a particular tab.

```typescript theme={null}
headlessService.fetchNotifications({
  listener: (result: FetchResult<IPaginatedResponse<IMessage>>) => {
    console.log(result);
  },
  onSuccess: (response: IPaginatedResponse<IMessage>) => {
    console.log(
      response.data,
      response.page,
      response.totalCount,
      response.pageSize
    );
  },
  page: pageNumber,
  query: { 
    feedIdentifier: "feedId", 
    read: false, 
    seen: true, 
    // payload sent while triggering the workflow
    payload: {
      message : "Notification message",
      type: "product",
    } 
  },
  storeId: "storeId",
});
```

### method args interface

```typescript theme={null}
interface IFetchNotifications {
  page?: number;
  storeId?: string;
  query?: IStoreQuery;
  listener: (result: FetchResult<IPaginatedResponse<IMessage>>) => void;
  onSuccess?: (messages: IPaginatedResponse<IMessage>) => void;
  onError?: (error: unknown) => void;
}
```

## fetchUserPreferences

Fetches the user [preferences](/subscribers/preferences)

```typescript theme={null}
headlessService.fetchUserPreferences({
  listener: (result: FetchResult<IUserPreferenceSettings[]>) => {
    console.log(result);
  },
  onSuccess: (settings: IUserPreferenceSettings[]) => {
    console.log(settings);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
});
```

### method args interface

```typescript theme={null}
interface IFetchUserPreferences {
  listener: (result: FetchResult<IUserPreferenceSettings[]>) => void;
  onSuccess?: (settings: IUserPreferenceSettings[]) => void;
  onError?: (error: unknown) => void;
}
```

## updateUserPreferences

Updates the user [preferences](/subscribers/preferences).

```typescript theme={null}
headlessService.updateUserPreferences({
  listener: (
    result: UpdateResult<
      IUserPreferenceSettings,
      unknown,
      IUpdateUserPreferencesVariables
    >
  ) => {
    console.log(result);
  },
  onSuccess: (settings: IUserPreferenceSettings) => {
    console.log(settings);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  templateId: "templateId",
  channelType: "SMS",
  checked: true,
});
```

### method args interface

```typescript theme={null}
interface IUpdateUserPreferences {
  templateId: IUpdateUserPreferencesVariables["templateId"];
  channelType: IUpdateUserPreferencesVariables["channelType"];
  checked: IUpdateUserPreferencesVariables["checked"];
  listener: (
    result: UpdateResult<
      IUserPreferenceSettings,
      unknown,
      IUpdateUserPreferencesVariables
    >
  ) => void;
  onSuccess?: (settings: IUserPreferenceSettings) => void;
  onError?: (error: unknown) => void;
}
```

## markNotificationsAsRead

Mark a single or multiple notifications as read using the message id.

```typescript theme={null}
headlessService.markNotificationsAsRead({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: ["messageOne", "messageTwo"],
});
```

### method args interface

```typescript theme={null}
interface IMarkNotificationsAsRead {
  messageId: IMessageId;
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## markNotificationsAsSeen

Mark a single or multiple notifications as seen using the message id.

```typescript theme={null}
headlessService.markNotificationsAsSeen({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: ["messageOne", "messageTwo"],
});
```

### method args interface

```
interface IMarkNotificationsAsSeen {
  messageId: IMessageId;
  listener: (result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}

```

## markNotificationsAs

Mark a single or multiple notifications using the message id.

```typescript theme={null}
headlessService.markNotificationsAs({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: ["messageOne", "messageTwo"],
  mark: { seen: true, read: true };
});
```

### method args interface

```typescript theme={null}
interface IMarkNotificationsAs {
  messageId: IMessageId;
  mark: { seen?: boolean; read?: boolean };
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: IMessageId }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## removeNotification

Removes a single notification using the message id.

```typescript theme={null}
headlessService.removeNotification({
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: string }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: "messageOne",
});
```

### method args interface

```typescript theme={null}
interface IRemoveNotification {
  messageId: string;
  listener: (
    result: UpdateResult<IMessage, unknown, { messageId: string }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## removeNotifications

<Note>This method is available from version 0.23.1</Note>

Removes multiple notifications using array of message ids (limit of 100).

```typescript theme={null}
headlessService.removeNotifications({
  listener: (
    result: UpdateResult<void, unknown, { messageIds: string[] }>
  ) => {
    console.log(result);
  },
  onSuccess: (message: IMessage) => {
    console.log(message);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageIds: ["message_id_1", "message_id_2" ],
});
```

### method args interface

```typescript theme={null}
interface IRemoveNotification {
  messageIds: string[];
  listener: (
    result: UpdateResult<void, unknown, { messageIds: string[] }>
  ) => void;
  onSuccess?: (message: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## removeAllNotifications

Removes all notifications. Can be used to remove all notifications of a feed by passing the `feedId`

```typescript theme={null}
headlessService.removeAllNotifications({
  listener: (result: UpdateResult<void, unknown, undefined>) => {
    console.log(result);
  },
  onSuccess: () => {
    console.log("success");
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  feedId: "feedOne",
});
```

### method args interface

```typescript theme={null}
interface IRemoveAllNotifications {
  feedId?: string;
  listener: (result: UpdateResult<void, unknown, undefined>) => void;
  onSuccess?: () => void;
  onError?: (error: unknown) => void;
}
```

## updateAction

Updates the action button for the notifications.

```typescript theme={null}
headlessService.updateAction({
  listener: (
    result: UpdateResult<IMessage, unknown, IUpdateActionVariables>
  ) => {
    console.log(result);
  },
  onSuccess: (data: IMessage) => {
    console.log(data);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  messageId: "messageOne",
  actionButtonType: "primary",
  status: "done",
  payload: {
    abc: "def",
  },
});
```

### method args interface

```typescript theme={null}
interface IUpdateAction {
  messageId: IUpdateActionVariables["messageId"];
  actionButtonType: IUpdateActionVariables["actionButtonType"];
  status: IUpdateActionVariables["status"];
  payload?: IUpdateActionVariables["payload"];
  listener: (
    result: UpdateResult<IMessage, unknown, IUpdateActionVariables>
  ) => void;
  onSuccess?: (data: IMessage) => void;
  onError?: (error: unknown) => void;
}
```

## markAllMessagesAsRead

Mark subscriber's all unread messages as read. Can be used to mark all messages as read of a single or multiple feeds by passing the `feedId`

```typescript theme={null}
headlessService.markAllMessagesAsRead({
  listener: (result: UpdateResult<number, unknown, undefined>) => {
    console.log(result);
  },
  onSuccess: (count: number) => {
    console.log(count);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  feedId: ["feedOne", "feedTwo"],
});
```

### method args interface

```typescript theme={null}
interface IMarkAllMessagesAsRead {
  listener: (result: UpdateResult<number, unknown, undefined>) => void;
  onSuccess?: (count: number) => void;
  onError?: (error: unknown) => void;
  feedId?: IFeedId;
}
```

## markAllMessagesAsSeen

Mark subscriber's all unread messages as seen. Can be used to mark all messages as seen of a single or multiple feeds by passing the `feedId`

```typescript theme={null}
headlessService.markAllMessagesAsSeen({
  listener: (result: UpdateResult<number, unknown, undefined>) => {
    console.log(result);
  },
  onSuccess: (count: number) => {
    console.log(count);
  },
  onError: (error: unknown) => {
    console.error(error);
  },
  feedId: ["feedOne", "feedTwo"],
});
```

### method args interface

```typescript theme={null}
interface IMarkAllMessagesAsSeen {
  listener: (result: UpdateResult<number, unknown, undefined>) => void;
  onSuccess?: (count: number) => void;
  onError?: (error: unknown) => void;
  feedId?: IFeedId;
}
```

## Types and Interfaces

```typescript theme={null}
interface IHeadlessServiceOptions {
  backendUrl?: string;
  socketUrl?: string;
  applicationIdentifier: string;
  subscriberId?: string;
  subscriberHash?: string;
  config?: {
    retry?: number;
    retryDelay?: number;
  };
}

interface ISession {
  token: string;
  profile: ISubscriberJwt;
}

interface ISubscriberJwt {
  _id: string;
  firstName: string;
  lastName: string;
  email: string;
  subscriberId: string;
  organizationId: string;
  environmentId: string;
  aud: "widget_user";
}

interface IUpdateUserPreferencesVariables {
  templateId: string;
  channelType: string;
  checked: boolean;
}

enum ButtonTypeEnum {
  PRIMARY = "primary",
  SECONDARY = "secondary",
  CLICKED = "clicked",
}

enum MessageActionStatusEnum {
  PENDING = "pending",
  DONE = "done",
}

interface IUpdateActionVariables {
  messageId: string;
  actionButtonType: ButtonTypeEnum;
  status: MessageActionStatusEnum;
  payload?: Record<string, unknown>;
}

type FetchResult<T = unknown> = Pick<
  QueryObserverResult<T>,
  "data" | "error" | "status" | "isLoading" | "isFetching" | "isError"
>;

type UpdateResult<
  TData = unknown,
  TError = unknown,
  TVariables = unknown
> = Pick<
  MutationObserverResult<TData, TError, TVariables>,
  "data" | "error" | "status" | "isLoading" | "isError"
>;

type IMessageId = string | string[];
type IFeedId = string | string[];
```

<Tip>
  QueryObserverResult and MutationObserverResult are imported from
  the `@tanstack/query-core` library.
</Tip>


# Get Started
Source: https://v0.x-docs.novu.co/notification-center/client/headless/get-started



The headless version of Novu's notification library package provides users with a lightweight solution for integrating notification functionality into their web applications. With just the essential API methods, users can easily incorporate our notification system into any framework or vanilla JavaScript project, without being constrained by our default UI or dependencies.

## Installation

```bash theme={null}
npm install @novu/headless
```

Then, in your project import the headless service:

```
import { HeadlessService, FetchResult, ISession } from '@novu/headless';
```

## Initialize the session

To use the headless service and its features, you'll need to first initialize the session:

```tsx theme={null}
const headlessService = new HeadlessService({
  applicationIdentifier: "APPLICATION_IDENTIFIER",
  subscriberId: "SUBSCRIBER_ID",
});

headlessService.initializeSession({
  listener: (res: FetchResult<ISession>) => {
    console.log(res);
  },
  onSuccess: (session: ISession) => {
    console.log(session);
  },
  onError: (error) => {
    console.error(error);
  },
});
```

## Use your own backend and socket url

By default, Novu's hosted services of API and socket are used. Should you want, you could override them and configure your own.

```tsx theme={null}
const headlessService = new HeadlessService({
  applicationIdentifier: "APPLICATION_IDENTIFIER",
  subscriberId: "SUBSCRIBER_ID",
  backendUrl: "YOUR_BACKEND_URL",
  socketUrl: "YOUR_SOCKET_URL",
});

headlessService.initializeSession({
  listener: (session) => {
    console.log(session);
  },
  onSuccess: (session) => {
    console.log(session);
  },
  onError: (error) => {
    console.error(error);
  },
});
```

## Fetch Notifications

```jsx theme={null}
import { IPaginatedResponse, IMessage } from "@novu/headless";

headlessService.fetchNotifications({
  listener: ({ data, error, isError, isFetching, isLoading, status }) => {
    console.log({ data, error, isError, isFetching, isLoading, status });
  },
  onSuccess: (response: IPaginatedResponse<IMessage>) => {
    console.log(
      response.data,
      response.page,
      response.totalCount,
      response.pageSize
    );
  },
  page: 1, // page number to be fetched
});
```

<Note>fetchNotifications and other methods of the headless service should be used after initializing the session using headlessService.initializeSession</Note>

## HMAC Encryption

To use the Hash-Based Message Authentication Codes pass the HMAC code to the headless service:

```typescript theme={null}
const headlessService = new HeadlessService({
  applicationIdentifier: "APP_ID_FROM_ADMIN_PANEL",
  subscriberId: "USER_ID",
  subscriberHash: "HASHED_SUBSCRIBER_ID",
});
```

## Realtime Sockets

Novu headless library provides listenUnseenCountChange API to listen to real-time socket changes and get updates about new notifications added to the user's feed.

### unseen count changes

```typescript theme={null}
headlessService.listenUnseenCountChange({
  // this will run every time there's a change in the `unseen_count` in real-time
  listener: (unseenCount: number) => {
    console.log(unseenCount);
  },
});
```

### unread count changes

```typescript theme={null}
headlessService.listenUnreadCountChange({
  // this will run every time there's a change in the `unread_count` in real-time
  listener: (unreadCount: number) => {
    console.log(unreadCount);
  },
});
```

<Tip>
  If you're ready to start using the Headless Notification Center, check out our [guide!](/guides/headless-notification-center-guide)
</Tip>

[Explore Implementation of the Headless Library in an App](https://github.com/novuhq/novu-headless-demo-app)

[Headless Demo](https://headlessdemo.vercel.app)

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="How to use headless library for multiple users? ">
    We have `headless.initializeSession` method to generate token and initialize the session. If user log out and new user login, then calling again this method with second user subscriberId will generate new token and new session.
  </Accordion>

  <Accordion title="Can headless be used with mobile based platforms like flutter and react native?">
    Currently, headless can not be used with react native and flutter. Checkout the progress on mobile platform support on github issue [#4499](https://github.com/novuhq/novu/issues/4499).
  </Accordion>
</AccordionGroup>


# Iframe Embed
Source: https://v0.x-docs.novu.co/notification-center/client/iframe



If you are using a (currently) unsupported client framework, you can use our embedded script. This will generate the notification center inside an iframe

```html theme={null}
<script>
  (function (n, o, t, i, f) {
    n[i] = {};
    var m = ["init", "on"];
    n[i]._c = [];
    m.forEach(
      (me) =>
        (n[i][me] = function () {
          n[i]._c.push([me, arguments]);
        })
    );
    var elt = o.createElement(f);
    elt.type = "text/javascript";
    elt.async = true;
    elt.src = t;
    var before = o.getElementsByTagName(f)[0];
    before.parentNode.insertBefore(elt, before);
  })(
    window,
    document,
    "https://embed.novu.co/embed.umd.min.js",
    "novu",
    "script"
  );

  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
    },
    {
      subscriberId: "SUBSCRIBER_ID",
      email: "SUBSCRIBER_EMAIL",
      first_name: "SUBSCRIBER_FIRST_NAME",
      last_name: "SUBSCRIBER_LAST_NAME",
    }
  );
</script>
```

Replace the selectors for the bell icon and the unseen badge within your code. Let's take a look at this example code:

```html theme={null}
<nav>
  <div id="notification-bell">
    <i class="fa fa-bell"></i>
    <span id="unseen-badge"></span>
  </div>
</nav>
```

## Customizing the dropdown position

Optionally, the embedded init script receives a position object, you can use this to specify the `left` and `top` position of the notification center.

```html theme={null}
<script>
  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      position: {
        top: "50px",
        left: "100px",
      },
    },
    {
      ...subscriberProps,
    }
  );
</script>
```

## Customizing the theme

The notification center component can be customized by passing a `theme` to the init script. Checkout all possible theme [properties](/notification-center/client/react/api-reference).

```html theme={null}
<script>
  const customTheme = {
    light: {
      layout: {
        background: "red",
      },
    },
  };

  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      theme: customTheme,
    },
    {
      ...subscriberProps,
    }
  );
</script>
```

## Customizing the UI language

The language of the UI can be customized by passing an `i18n` component to the init script. More information on all possible [properties](/notification-center/client/react/customization#customize-the-ui-language).

```html theme={null}
<script>
  const customLanguage = {
    lang: "en",
    translations: {
      notifications: "My custom notifications!",
    },
  };

  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      i18n: customLanguage,
    },
    {
      ...subscriberProps,
    }
  );
</script>
```

## Handle User Interaction

In order to handle certain events like the user clicking on the notification, or clicking on an action button inside a notification, you can listen for these events and handle them accordingly.

```html theme={null}
<script>
  novu.on("notification_click", (notification) => {
    // do custom logic here
  });

  novu.on("action_click", ({ templateIdentifier, type, notification }) => {
    // do custom logic here
  });
</script>
```

## Enabling HMAC Encryption

In order to enable Hash-Based Message Authentication Codes, you need to visit the admin panel's In-App settings page and enable HMAC encryption for your environment.

The next step would be to generate an HMAC encrypted subscriberId on your backend:

```javascript theme={null}
import { createHmac } from "crypto";

const hmacHash = createHmac("sha256", process.env.NOVU_API_KEY)
  .update(subscriberId)
  .digest("hex");
```

Then pass the created HMAC to your client side application forward it to the embed initialization script:

```html theme={null}
<script>
  novu.init(
    "APPLICATION_IDENTIFIER",
    {
      unseenBadgeSelector: "#unseen-badge",
      bellSelector: "#notification-bell",
      position: {
        top: "50px",
        left: "100px",
      },
    },
    {
      subscriberId: "SUBSCRIBER_ID_PLAIN_VALUE",
      subscriberHash: "SUBSCRIBER_ID_HASH_VALUE",
    }
  );
</script>
```

## Example

[![Edit novu-iframe-nc](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/novu-iframe-nc-t9ns9d?fontsize=14\&hidenavigation=1\&theme=dark)

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="The notification bell is not showing in the iframe.">
    We use font awesome bell icon. Make sure you have added the font awesome CSS cdn link in the head tag.

    ```html theme={null}
    <link
      rel="stylesheet"
      href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css"
      integrity="sha512-iecdLmaskl7CVkqkXNQ/ZH/XLlvWZOJyj7Yy7tcenmpD1ypASozpmT/E0iPtmFIB46ZmdtAc9eNBvH0H/ZpiBw=="
      crossorigin="anonymous"
      referrerpolicy="no-referrer"
    />
    ```
  </Accordion>
</AccordionGroup>


# API Reference
Source: https://v0.x-docs.novu.co/notification-center/client/react/api-reference



## React Notification Center API Reference

This page contains complete documentation about the React Notification Center package. You can find here the list of all the components, hooks, and props that you can use.

## Components

Components are the building blocks of the React Notification Center package. They are used to build the UI of the notification center.

## NovuProvider

The NovuProvider is the root component of the React Notification Center package. It is used to wrap the components code and provide the notifications feed context to all its children.
It's responsible for establishing the notification center session, managing the web socket connection, and fetching the notifications feed.

| Prop                    | Type                                                                           | Description                                                                                                                                                                                                                                                                                                                                                                     |
| ----------------------- | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| backendUrl              | string (optional)                                                              | The custom backend URL, your own deployed instance of the API. The default is [https://api.novu.co.app/](https://api.novu.co.app/).                                                                                                                                                                                                                                             |
| socketUrl               | string (optional)                                                              | The custom socket URL, your own deployed instance of the WS app. The default is [https://ws.novu.co/](https://ws.novu.co/).                                                                                                                                                                                                                                                     |
| applicationIdentifier   | string                                                                         | The app id is taken from the Novu Settings -> API Keys tab.                                                                                                                                                                                                                                                                                                                     |
| subscriberId            | string                                                                         | The unique user id from your system.                                                                                                                                                                                                                                                                                                                                            |
| subscriberHash          | string (optional)                                                              | The HMAC encrypted subscriberId. Read about [hmac encryption](/notification-center/client/react/get-started#hmac-encryption)                                                                                                                                                                                                                                                    |
| stores                  | [IStore](#store-interface) (optional)                                          | The connection object between feed and notification center tab.                                                                                                                                                                                                                                                                                                                 |
| i18n                    | [ITranslationEntry \| ITranslationContent](#i18nlanguage-interface) (optional) | The prop allows to configure the UI language.                                                                                                                                                                                                                                                                                                                                   |
| styles                  | [NotificationCenterStyles](#styles-interface) (optional)                       | The prop allowing to style the notification center. It's based on the CSSInterpolation object from the [@emotion/css](https://emotion.sh/docs/@emotion/css#object-styles) package.                                                                                                                                                                                              |
| initialFetchingStrategy | [IFetchingStrategy](#fetching-strategy-interface) (optional)                   | The fetching strategy. By default notifications feed and user preferences are not fetched until the notification center is opened. You might need to tweak this configuration when building a custom UI and if you need to fetch notifications right away. Also it's possible to change it when some action happens using the useNovuContext hook and setFetchingStrategy prop. |
| children                | object                                                                         | The ReactNode object type, the "consumer" of the NovuProvider context.                                                                                                                                                                                                                                                                                                          |
| onLoad                  | [function](#props-interface) (optional)                                        | The function that is called with an organization object after the notification center session is initialized.                                                                                                                                                                                                                                                                   |

### Props interface

```typescript theme={null}
interface INovuProviderProps {
  backendUrl?: string;
  socketUrl?: string;
  applicationIdentifier: string;
  subscriberId?: string;
  subscriberHash?: string;
  stores?: IStore[];
  i18n?: I18NLanguage | ITranslationEntry;
  styles?: INotificationCenterStyles;
  initialFetchingStrategy?: Partial<IFetchingStrategy>;
  children: React.ReactNode;
  onLoad?: (data: { organization: IOrganizationEntity }) => void;
}
```

### Store interface

```typescript theme={null}
interface IStore {
  storeId: string;
  query?: IStoreQuery;
}

interface IStoreQuery {
  feedIdentifier?: string | string[];
  seen?: boolean;
  read?: boolean;
  limit?: number; 
  payload?: Record<string, unknown>;
}
```

### I18NLanguage interface

```typescript theme={null}
type I18NLanguage = 'en' | 'de' ...;

interface ITranslationContent {
  readonly notifications: string;
  readonly markAllAsRead: string;
  readonly poweredBy: string;
  readonly settings: string;
  readonly removeMessage: string;
  readonly markAsRead: string;
  readonly markAsUnRead: string;
}

interface ITranslationEntry {
  readonly translations: Partial<ITranslationContent>;
  readonly lang: string;
}

```

### Styles interface

```typescript theme={null}
interface NotificationCenterStyles {
  bellButton?: ObjectWithRoot<{
    dot?: CSSFunctionOrObject;
  }>;
  unseenBadge?: CSSFunctionOrObject;
  popover?: {
    arrow?: CSSFunctionOrObject;
    dropdown?: CSSFunctionOrObject;
  };
  loader?: ObjectWithRoot;
  layout?: ObjectWithRoot;
  header?: ObjectWithRoot<{
    title?: CSSFunctionOrObject;
    markAsRead?: CSSFunctionOrObject;
    cog?: CSSFunctionOrObject;
    backButton?: CSSFunctionOrObject;
  }>;
  tabs?: {
    tabsList?: CSSFunctionOrObject;
    tab?: CSSFunctionOrObject;
    tabLabel?: CSSFunctionOrObject;
    tabIcon?: CSSFunctionOrObject;
  };
  accordion?: {
    item?: CSSFunctionOrObject;
    content?: CSSFunctionOrObject;
    control?: CSSFunctionOrObject;
    chevron?: CSSFunctionOrObject;
  };
  switch?: ObjectWithRoot<{
    input?: CSSFunctionOrObject;
    track?: CSSFunctionOrObject;
    thumb?: CSSFunctionOrObject;
  }>;
  footer?: ObjectWithRoot<{
    title?: CSSFunctionOrObject;
  }>;
  notifications?: ObjectWithRoot<{
    listItem?: {
      read?: CSSFunctionOrObject;
      unread?: CSSFunctionOrObject;
      layout?: CSSFunctionOrObject;
      contentLayout?: CSSFunctionOrObject;
      title?: CSSFunctionOrObject;
      timestamp?: CSSFunctionOrObject;
      dotsButton?: CSSFunctionOrObject;
      buttons?: ObjectWithRoot<{
        primary?: CSSFunctionOrObject;
        secondary?: CSSFunctionOrObject;
      }>;
    };
  }>;
  actionsMenu?: {
    arrow?: CSSFunctionOrObject;
    dropdown?: CSSFunctionOrObject;
    item?: CSSFunctionOrObject;
  };
  preferences?: ObjectWithRoot<{
    item?: {
      title?: CSSFunctionOrObject;
      channels?: CSSFunctionOrObject;
      divider?: CSSFunctionOrObject;
      content?: {
        icon?: CSSFunctionOrObject;
        channelLabel?: CSSFunctionOrObject;
        success?: CSSFunctionOrObject;
      };
    };
  }>;
}

type CSSFunctionInterpolation = (args: {
  theme: INovuTheme;
  common: ICommonTheme;
  colorScheme: ColorScheme;
}) => CSSInterpolation;

type CSSFunctionOrObject = CSSFunctionInterpolation | CSSInterpolation;

type ObjectWithRoot<T = {}> = T & {
  root: CSSFunctionOrObject;
};
```

<Accordion title="How to use the Styles Interface?">
  To use the Styles Interface, you need to identify the property you need to modify to achieve your desired look and pass it as an object in the `styles` prop.

  <br />

  As listed in the [Styles Interface](/notification-center/client/react/api-reference#styles-interface), the notification center is made up of a number of components which can each be individually customized.

  <br />

  You can also check out our [docs on customizing styles](https://docs.novu.co/notification-center/client/react/api-reference#styles-interface) to see how to define styles for various components that make up the notification center.

  <br />

  #### Let's take an example to see this in action:

  By default, this is how the notification center looks:

  <Frame>
    <img />
  </Frame>

  Say, you wanted the text color to match the accent color. You just need to go over to the [docs on customizing styles](https://docs.novu.co/notification-center/client/react/api-reference#styles-interface) and find out which property needs to be modified. In our case, we need to change the `color` property as evident here:

  <Frame>
    <img />
  </Frame>

  Now, that we know which property needs to change, all we need to do is pass an object to the `styles` prop while maintaining the nesting of object keys:

  ```javascript theme={null}
  <div className='bell'>
      <NovuProvider
          subscriberId={process.env.REACT_APP_SUB_ID}
          applicationIdentifier={process.env.REACT_APP_APP_ID}

          styles={{ notifications: { listItem: { layout: { color: '#E3554D' } } } }}

      >
          <PopoverNotificationCenter >
              {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
          </PopoverNotificationCenter>
      </NovuProvider>
  </div >
  ```

  This gives us the desired result:

  <Frame>
    <img />
  </Frame>

  <Note>Please have a look at our [docs on customizing styles](https://docs.novu.co/notification-center/client/react/api-reference#styles-interface) to see how to define styles for various components of the notification center.</Note>
</Accordion>

### Fetching strategy interface

```typescript theme={null}
interface IFetchingStrategy {
  fetchUnseenCount: boolean;
  fetchOrganization: boolean;
  fetchNotifications: boolean;
  fetchUserPreferences: boolean;
}
```

## PopoverNotificationCenter

The floating popover component that appears when clicking on the [NotificationBell](#notificationbell) button. It renders the [NotificationCenter](#notificationcenter) component inside its content.

| Prop                       | Type                                            | Description                                                                                                                                                                                                  |
| -------------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| position                   | string (optional)                               | Position of the popover relative to the bell icon. It is based on the [Mantine Popover](https://mantine.dev/core/popover/?t=props). The default is set to `bottom-end`.                                      |
| offset                     | number (optional)                               | Gap between the Bell icon and Popover in px.                                                                                                                                                                 |
| colorScheme                | string                                          | The UI light or dark mode.                                                                                                                                                                                   |
| theme                      | [INovuTheme](#the-theme-interface) (optional)   | The theme object allowing you to override light and dark colors of the UI components. Deprecated for styling, please use the [styles](#styles-interface) prop on the NovuProvider.                           |
| tabs                       | [ITab](#the-tab-interface)(optional)            | Allows to define separate UI tabs for the notifications feed. The array of connection objects between the feed tab and [stores](#store-interface) (that you define on the NovuProvider) and feed identifier. |
| listItem                   | [ListItem](#the-list-item-interface) (optional) | The render function allowing you to define the custom element for the notification list item.                                                                                                                |
| showUserPreferences        | boolean (optional)                              | The flag that enables to show/hide the user preferences. By default it is enabled.                                                                                                                           |
| allowedNotificationActions | boolean (optional)                              | The flag that enables to show/hide the dots menu for actions performed on a notification. By default it is enabled.                                                                                          |
| onUrlChange                | function (optional)                             | The function that is called when the notification item has a CTA of type redirect and is clicked.                                                                                                            |
| onNotificationClick        | function (optional)                             | The function that is called when the notification item is clicked.                                                                                                                                           |
| onUnseenCountChanged       | function (optional)                             | The function that is called when the unseen notifications count changed.                                                                                                                                     |
| children                   | function                                        | The render function that allows you to define the custom bell button. It's called with an argument that has unseenCount prop the number of unseen notifications.                                             |
| header                     | function (optional)                             | The render function that allows you to define the custom header component.                                                                                                                                   |
| footer                     | function (optional)                             | The render function that allows you to define the custom footer component.                                                                                                                                   |
| emptyState                 | JSX.Element (optional)                          | The render function that allows you to define the custom component for the empty notifications list state.                                                                                                   |
| onActionClick              | function (optional)                             | The callback function triggered when the notification button is clicked.                                                                                                                                     |
| actionsResultBlock         | function (optional)                             | The render function that allows you to define the custom component that will be rendered after the notification button is clicked.                                                                           |
| onTabClick                 | function (optional)                             | The callback function triggered when the notifications feed tab changes.                                                                                                                                     |
| preferenceFilter           | function (optional)                             | The callback function triggered when filtering the subscriber preference.                                                                                                                                    |

### Props interface

```typescript theme={null}
interface IPopoverNotificationCenterProps {
  position?: PopoverProps["position"];
  offset?: number;
  colorScheme: ColorScheme;
  theme?: INovuThemePopoverProvider;
  tabs?: ITab[];
  listItem?: ListItem;
  showUserPreferences?: boolean;
  allowedNotificationActions?: boolean;
  onUrlChange?: (url: string) => void;
  onNotificationClick?: (notification: IMessage) => void;
  onUnseenCountChanged?: (unseenCount: number) => void;
  children: (props: INotificationBellProps) => JSX.Element;
  header?: () => JSX.Element;
  footer?: () => JSX.Element;
  emptyState?: JSX.Element;
  onActionClick?: (
    templateIdentifier: string,
    type: ButtonTypeEnum,
    message: IMessage
  ) => void;
  actionsResultBlock?: (
    templateIdentifier: string,
    messageAction: IMessageAction
  ) => JSX.Element;
  onTabClick?: (tab: ITab) => void;
  preferenceFilter?: (userPreference: IUserPreferenceSettings) => boolean;
}
```

More information about the [IMessage](#the-notification-imessage-model) interface, and the [theme](#the-theme-interface) interface.

### The tab interface

```typescript theme={null}
interface ITab {
  name: string;
  storeId: string;
}
```

### The list item interface

```typescript theme={null}
type ListItem = (
  message: IMessage,
  onActionButtonClick: (actionButtonType: ButtonTypeEnum) => void,
  onNotificationClick: () => void
) => JSX.Element;
```

## NotificationCenter

The component that renders the notifications feed and allows to update the user preferences.

| Prop                       | Type                                            | Description                                                                                                                                                                                                  |
| -------------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| colorScheme                | string                                          | The UI light or dark mode.                                                                                                                                                                                   |
| theme                      | [INovuTheme](#the-theme-interface) (optional)   | The theme object allowing you to override light and dark colors of the UI components. Deprecated for styling, please use the [styles](#styles-interface) prop on the NovuProvider.                           |
| tabs                       | [ITab](#the-tab-interface)(optional)            | Allows to define separate UI tabs for the notifications feed. The array of connection objects between the feed tab and [stores](#store-interface) (that you define on the NovuProvider) and feed identifier. |
| listItem                   | [ListItem](#the-list-item-interface) (optional) | The render function allowing you to define the custom element for the notification list item.                                                                                                                |
| showUserPreferences        | boolean (optional)                              | The flag that enables to show/hide the user preferences. By default it is enabled.                                                                                                                           |
| allowedNotificationActions | boolean (optional)                              | The flag that enables to show/hide the dots menu for actions performed on a notification. By default it is enabled.                                                                                          |
| onUrlChange                | function (optional)                             | The function that is called when the notification item has a CTA of type redirect and is clicked.                                                                                                            |
| onNotificationClick        | function (optional)                             | The function that is called when the notification item is clicked.                                                                                                                                           |
| onUnseenCountChanged       | function (optional)                             | The function that is called when the unseen notifications count changed.                                                                                                                                     |
| header                     | function (optional)                             | The render function that allows you to define the custom header component.                                                                                                                                   |
| footer                     | function (optional)                             | The render function that allows you to define the custom footer component.                                                                                                                                   |
| emptyState                 | JSX.Element (optional)                          | The render function that allows you to define the custom component for the empty notifications list state.                                                                                                   |
| onActionClick              | function (optional)                             | The callback function triggered when the notification button is clicked.                                                                                                                                     |
| actionsResultBlock         | function (optional)                             | The render function that allows you to define the custom component that will be rendered after the notification button is clicked.                                                                           |
| onTabClick                 | function (optional)                             | The callback function triggered when the notifications feed tab changes.                                                                                                                                     |
| preferenceFilter           | function (optional)                             | The callback function triggered when filtering the subscriber preference.                                                                                                                                    |

### Props interface

```typescript theme={null}
interface INotificationCenterProps {
  colorScheme: ColorScheme;
  theme?: INovuThemeProvider;
  tabs?: ITab[];
  listItem?: ListItem;
  showUserPreferences?: boolean;
  allowedNotificationActions?: boolean;
  onUrlChange?: (url: string) => void;
  onNotificationClick?: (notification: IMessage) => void;
  onUnseenCountChanged?: (unseenCount: number) => void;
  header?: () => JSX.Element;
  footer?: () => JSX.Element;
  emptyState?: JSX.Element;
  onActionClick?: (
    templateIdentifier: string,
    type: ButtonTypeEnum,
    message: IMessage
  ) => void;
  actionsResultBlock?: (
    templateIdentifier: string,
    messageAction: IMessageAction
  ) => JSX.Element;
  onTabClick?: (tab: ITab) => void;
  preferenceFilter?: (userPreference: IUserPreferenceSettings) => boolean;
}
```

## NotificationBell

The component that renders the notification bell with the unseen notifications count.

| Prop                       | Type                        | Description                                                  |
| -------------------------- | --------------------------- | ------------------------------------------------------------ |
| unseenCount                | number (optional)           | The number of unseen notifications.                          |
| unseenBadgeColor           | string or object (optional) | The unseen notifications count badge color.                  |
| unseenBadgeBackgroundColor | string (optional)           | The background color of the notification unseen count badge. |
| colorScheme                | string (optional)           | The UI light or dark mode.                                   |

### Props interface

```typescript theme={null}
interface INotificationBellProps {
  unseenCount?: number;
  unseenBadgeColor?: string | ISvgStopColor;
  unseenBadgeBackgroundColor?: string;
  colorScheme?: ColorScheme;
}

interface ISvgStopColor {
  stopColor?: string;
  stopColorOffset?: string;
}
```

## Hooks

### useNotifications

This hook that allows you to get the notifications feed data and unseen notifications count. The notifications are fetched only when the `fetchingStrategy.fetchNotifications` is set to true interface, check the `initialFetchingStrategy` prop on the [NovuProvider](#novuprovider) component.

```typescript theme={null}
const result = useNotifications();
```

`useNotifications` hook return interface

```typescript theme={null}
interface INotificationsContext {
  storeId: string;
  storeQuery: IStoreQuery;
  stores: IStore[];
  unseenCount: number;
  notifications: IMessage[];
  hasNextPage: boolean;
  isLoading: boolean;
  isFetching: boolean;
  isFetchingNextPage: boolean;
  setStore: (storeId?: string) => void;
  fetchNextPage: () => void;
  refetch: () => void;
  markNotificationAsRead: (messageId: string) => void;
  markNotificationAsUnRead: (messageId: string) => void;
  markNotificationAsSeen: (messageId: string) => void;
  markFetchedNotificationsAsRead: () => void;
  markFetchedNotificationsAsSeen: () => void;
  markAllNotificationsAsRead: () => void;
  markAllNotificationsAsSeen: () => void;
  removeMessage: (messageId: string) => void;
  removeAllMessages: (feedId?: string) => void;
}
```

Description of the `useNotifications` hook return interface properties

| Prop                           | Type                                             | Description                                                                                                           |
| ------------------------------ | ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| storeId                        | string                                           | active `storeId`                                                                                                      |
| stores                         | [IStore\[\]](#store-interface)                   | array of [IStore](#store-interface) passed to the [NovuProvider](#novuprovider).                                      |
| unseenCount                    | number                                           | unseen notifications (messages) count.                                                                                |
| notifications                  | [IMessage\[\]](#the-notification-imessage-model) | The feed notifications array.                                                                                         |
| hasNextPage                    | boolean                                          | flag indicating if the next notifications page to fetch is available.                                                 |
| isLoading                      | boolean                                          | flag indicating if the initial notifications fetch request is on the fly.                                             |
| isFetching                     | boolean                                          | flag indicating if the notifications are fetching including initial fetch.                                            |
| isFetchingNextPage             | boolean                                          | flag indicating if the next notifications page request in on the fly.                                                 |
| setStore                       | function                                         | function used to change the current notifications [IStore](#store-interface)                                          |
| fetchNextPage                  | function                                         | function that fires the fetch request for the next notifications page.                                                |
| refetch                        | function                                         | function used to refetch all the notifications, when multiple page requests were made it will refetch all of them.    |
| markNotificationAsRead         | function                                         | function takes the notification (message) `messageId` as an argument and marks that notification (message) as read.   |
| markNotificationAsUnRead       | function                                         | function takes the notification (message) `messageId` as an argument and marks that notification (message) as unread. |
| markNotificationAsSeen         | function                                         | function takes the notification (message) `messageId` as an argument and marks that notification (message) as seen.   |
| markFetchedNotificationsAsRead | function                                         | function marks all the fetched notifications as read.                                                                 |
| markFetchedNotificationsAsSeen | function                                         | function allowing you to mark all the fetched notifications as seen.                                                  |
| markAllNotificationsAsRead     | function                                         | function allowing you to mark all notifications as read.                                                              |
| markAllNotificationsAsSeen     | function                                         | function allowing you to mark notifications as seen.                                                                  |
| removeMessage                  | function                                         | function takes the notification (message) `messageId` as an argument and delete a notification.                       |
| removeAllMessages              | function                                         | The function allowing you to delete all notifications or a specific feed's (store's) notifications at once.           |

### useFetchNotifications

`useFetchNotifications` can fetche the notifications for a particular feed. It's a thin version of the `useNotifications` hook and is based on the `useInfiniteQuery` hook from the `react-query` library. Notifications can be filtered using `payload` property. Check all properties of [IStoreQuery](#store-interface) interface. The notifications are fetched only when the `fetchingStrategy.fetchNotifications` is set to true interface, check the `initialFetchingStrategy` prop on the [NovuProvider](#novuprovider) component.

```typescript theme={null}
const query: IStoreQuery = {
  limit: 10,
  payload: {
    key: "value"
  }
};

const onSuccess = (data: IPaginatedResponse<IMessage>) => {};

const onError = (error: Error) => {};

const {
  data: notificationsPages,
  hasNextPage,
  isLoading,
  isFetching,
  isFetchingNextPage,
  fetchNextPage,
  refetch,
} = useFetchNotifications({ query }, { onSuccess, onError });
```

`useFetchNotifications` hook return args

```typescript theme={null}
interface IUseFetchNotificationsArgs {
  onSuccess?: (data: IPaginatedResponse<IMessage>) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useInfiniteQuery hook
}

```

`useFetchNotifications` hook return interface

```typescript theme={null}
interface InfiniteData<TData> {
  pages: TData[];
  pageParams: unknown[];
}

interface IUseUnseenCountResult {
  data: InfiniteData<IPaginatedResponse<IMessage>>;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useInfiniteQuery hook result
}
```

### useUnseenCount

`useUnseenCount` returns the total unseen notifications count. Under the hood it uses the socket connection to get the unseen count updates.

```typescript theme={null}
interface ICountData {
  count: number;
}

const onSuccess = ({ count }: ICountData) => {};

const onError = (error: Error) => {};

const { data, isLoading, isError, error } = useUnseenCount({ onSuccess, onError });
```

`useUnseenCount` hook args interface

```typescript theme={null}
interface IUseUnseenCountArgs {
  onSuccess?: (data: ICountData) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useUnseenCount` hook return interface

```typescript theme={null}
interface IUseUnseenCountResult {
  data?: ICountData;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useSocket

`useSocket` hooks is used to get the reference to socket object.

```typescript theme={null}
const { socket } = useSocket();
```

`useSocket` return interface

```typescript theme={null}
interface ISocket {
  on: (eventName: string, callback: (data: any) => void) => void;
  off: (eventName: string) => void;
}
```

`useSocket` supported events

| Event                  | Description                                              |
| ---------------------- | -------------------------------------------------------- |
| notification\_received | Triggered when a new notification is received            |
| unseen\_count\_changed | Triggered when the count of unseen notifications changes |
| unread\_count\_changed | Triggered when the count of unread notifications changes |

### useNovuContext

`useNovuContext` hook is used to get the reference to the [NovuProvider](#novuprovider) context.

```typescript theme={null}
const result = useNovuContext();
```

`useNovuContext` hook return interface

```typescript theme={null}
interface INovuProviderContext {
  backendUrl?: string;
  subscriberId?: string;
  applicationIdentifier?: string;
  isSessionInitialized: boolean;
  socketUrl?: string;
  subscriberHash: string;
  apiService: ApiService;
  socket?: ISocket;
  fetchingStrategy: IFetchingStrategy;
  setFetchingStrategy: (strategy: Partial<IFetchingStrategy>) => void;
  onLoad: (data: { organization: IOrganizationEntity }) => void;
}
```

### useFeedUnseenCount

`useFeedUnseenCount` hook fetches the unseen count for a particular feed.

```typescript theme={null}
interface ICountData {
  count: number;
}

const query: IStoreQuery = {
  feedIdentifier: "product-updates"
};

const onSuccess = (data: ICountData) => {};

const onError = (error: Error) => {};

const result = useFeedUnseenCount({ query }, { onSuccess, onError });
```

`useFeedUnseenCount` hook args interface

```typescript theme={null}
interface IUseFeedUnseenCountArgs {
  onSuccess?: (data: ICountData) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useFeedUnseenCount` hook return interface

```typescript theme={null}
interface IUseFeedUnseenCountResult {
  data?: ICountData;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useFetchOrganization

`useFetchOrganization` hok fetches the current organization information.

```typescript theme={null}
interface IOrganizationEntity {
  _id: string;
  name: string;
  members: {
    _id: string;
    _userId?: string;
    user?: Pick<IUserEntity, 'firstName' | '_id' | 'lastName' | 'email'>;
    roles: MemberRoleEnum[];
    invite?: IMemberInvite;
    memberStatus: MemberStatusEnum;
  }[];
  branding?: {
    color: string;
    logo: string;
    fontColor: string;
    fontFamily: string;
    contentBackground: string;
    direction: 'ltr' | 'rtl';
  };
}

const onSuccess = (data: IOrganizationEntity) => {};

const onError = (error: Error) => {};

const result = useFetchOrganization({ onSuccess, onError });
```

`useFetchOrganization` hook args interface

```typescript theme={null}
interface IUseFetchOrganizationArgs {
  onSuccess?: (data: IOrganizationEntity) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useFetchOrganization` hook return interface

```typescript theme={null}
interface IUseFetchOrganizationResult {
  data?: IOrganizationEntity;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useFetchUserPreferences

`useFetchUserPreferences` hook fetches the user preferences.

```typescript theme={null}
const onSuccess = (data: IUserPreferenceSettings[]) => {};

const onError = (error: Error) => {};

const result = useFetchUserPreferences({ onSuccess, onError });
```

`useFetchUserPreferences` hook args interface

```typescript theme={null}
interface IUseFetchUserPreferencesArgs {
  onSuccess?: (data: IUserPreferenceSettings[]) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useQuery hook
}
```

`useFetchUserPreferences` hook return interface

```typescript theme={null}
interface IUseFetchUserPreferencesResult {
  data?: IUserPreferenceSettings[];
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useQuery hook result
}
```

### useUpdateUserPreferences

`useUpdateUserPreferences` hook is used to update the user preferences.

```typescript theme={null}
interface IPreferenceChannels {
  email?: boolean;
  sms?: boolean;
  in_app?: boolean;
  chat?: boolean;
  push?: boolean;
}

interface IUserPreferenceSettings {
  template: { _id: string; name: string; critical: boolean };
  preference: { enabled: boolean; channels: IPreferenceChannels };
}

const onSuccess = (data: IUserPreferenceSettings) => {};

const onError = (error: Error) => {};

const { updateUserPreferences, isLoading, isError, error } = useUpdateUserPreferences({
  onSuccess,
  onError,
});
```

`useUpdateUserPreferences` hook args interface

```typescript theme={null}
interface IUserPreferencesArgs {
  onSuccess?: (data: IUserPreferenceSettings) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useUpdateUserPreferences` hook return interface

```typescript theme={null}
interface IUpdateUserPreferencesVariables {
  templateId: string; // workflowId of mongodbId type
  channelType: string;
  checked: boolean;
}

interface IUserPreferencesResult {
  updateUserPreferences: (variables: IUpdateUserPreferencesVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useUpdateAction

`useUpdateAction` hook can be used to update the notification action button status.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { updateAction, isLoading, isError, error } = useUpdateAction({ onSuccess, onError });
```

`useUpdateAction` hook args interface

```typescript theme={null}
interface IUseUpdateActionArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useUpdateAction` hook return interface

```typescript theme={null}
interface IUpdateActionVariables {
  messageId: string;
  actionButtonType: ButtonTypeEnum;
  status: MessageActionStatusEnum;
  payload?: Record<string, unknown>;
}

interface IUpdateActionResult {
  updateAction: (variables: IUpdateActionVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useMarkNotificationsAs

`useMarkNotificationsAs` hook that marks the notifications as read or seen.

```typescript theme={null}
const onSuccess = (data: IMessage[]) => {};

const onError = (error: Error) => {};

const { markNotificationsAs, isLoading, isError, error } = useMarkNotificationsAs({
  onSuccess,
  onError,
});
```

`useMarkNotificationsAs` hook args interface

```typescript theme={null}
interface IUseMarkNotificationsAsArgs {
  onSuccess?: (data: IMessage[]) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useMarkNotificationsAs` hook return interface

```typescript theme={null}
interface IMarkNotificationsAsVariables {
  messageId: IMessageId;
  seen: boolean;
  read: boolean;
}

interface IUseMarkNotificationsAsResult {
  markNotificationsAs: (args: IMarkNotificationsAsVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useRemoveNotification

`useRemoveNotification` hook allows you to remove a message. It will delete the message for the subscriber and will refetch the feed.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { removeNotification, isLoading, isError, error } = useRemoveNotification({
  onSuccess,
  onError,
});
```

`useRemoveNotification` hook args interface

```typescript theme={null}
interface IUseRemoveNotificationArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useRemoveNotification` hook return interface

```typescript theme={null}
interface IRemoveNotificationVariables {
  messageId: IMessageId;
}

interface IUseRemoveNotificationResult {
  removeNotification: (args: IRemoveNotificationVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useRemoveNotifications

<Note>This hook is available from version 0.23.1</Note>

`useRemoveNotifications` hook allows you to remove multiple messages with a limit of 100 messageIds in single call.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { removeNotifications, isLoading, isError, error } = useRemoveNotifications({
  onSuccess,
  onError,
});
```

`useRemoveNotifications` hook args interface

```typescript theme={null}
interface IUseRemoveNotificationArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useRemoveNotifications` hook return interface

```typescript theme={null}
interface IRemoveNotificationsVariables {
  messageIds: string[];
}

interface IUseRemoveNotificationResult {
  removeNotifications: (args: IRemoveNotificationsVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useRemoveAllNotifications

`useRemoveAllNotifications` hook allows you to remove all messages of all feeds. feedId can be used as param to delete only specific feed's messages.

```typescript theme={null}
const onSuccess = (data: IMessage) => {};

const onError = (error: Error) => {};

const { removeAllNotifications, isLoading, isError, error } = useRemoveAllNotifications({
  onSuccess,
  onError,
});
```

`useRemoveAllNotifications` hook args interface

```typescript theme={null}
interface IUseRemoveAllNotificationsArgs {
  onSuccess?: (data: IMessage) => void;
  onError?: (error: Error) => void;
  // ... many more from the react-query useMutation hook
}
```

`useRemoveAllNotifications` hook return interface

```typescript theme={null}
interface IRemoveAllNotificationsVariables {
  feedId?: string;
}

interface IUseRemoveAllNotificationsResult {
  removeAllNotifications: (args: IRemoveAllNotificationsVariables) => void;
  isLoading: boolean;
  isError: boolean;
  error?: Error;
  // ... many more from the react-query useMutation hook result
}
```

### useTranslations

`useTranslations` hook allows you to get the reference to the [translations](/notification-center/client/react/customization#customize-the-ui-language) object.

```typescript theme={null}
const result = useTranslations();
```

`useTranslations` returns interface

```typescript theme={null}
interface ITranslations {
  lang: string;
  t: (key: string) => string;
  dateFnsLocale: () => Locale;
}
```

### useNovuTheme

`useNovuTheme` hook can be used to get the reference to the [theme](#the-theme-interface) object.

```typescript theme={null}
const result = useNovuTheme();
```

`useNovuTheme` hook return interface

```typescript theme={null}
interface INovuThemeProviderContext {
  theme: INovuTheme;
  common: ICommonTheme;
  colorScheme: ColorScheme;
}
```

#### The theme interface

```typescript theme={null}
interface INovuTheme {
  layout?: IThemeLayout;
  header?: IThemeHeader;
  popover?: IThemePopover;
  actionsMenu?: IThemeActionsMenu;
  notificationItem?: IThemeNotificationListItem;
  userPreferences?: IThemeUserPreferences;
  footer?: IThemeFooter;
  loaderColor?: string;
}
```

#### `IThemeLayout`

| Property                   | Default Value (Light Theme)            | Default Value - (Dark Theme)    |
| -------------------------- | -------------------------------------- | ------------------------------- |
| background                 | #FFFFFF                                | #1E1E26                         |
| boxShadow                  | 0px 5px 15px rgba(122, 133, 153, 0.25) | 0px 5px 20px rgba(0, 0, 0, 0.2) |
| wrapper.secondaryFontColor | #BEBECC                                | #525266                         |

#### `IThemeHeader`

| Property       | Default Value (Light Theme)                   | Default Value - (Dark Theme)                  |
| -------------- | --------------------------------------------- | --------------------------------------------- |
| badgeColor     | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) |
| badgeTextColor | #FFFFFF                                       | #FFFFFF                                       |
| fontColor      | #828299                                       | #FFFFFF                                       |

#### `IThemePopover`

| Property   | Default Value (Light Theme) | Default Value - (Dark Theme) |
| ---------- | --------------------------- | ---------------------------- |
| arrowColor | #FFFFFF                     | #1E1E26                      |

#### `IThemeNotificationListItem`

| Property                                | Default Value (Light Theme)                             | Default Value - (Dark Theme)                            |
| --------------------------------------- | ------------------------------------------------------- | ------------------------------------------------------- |
| seen.fontColor                          | #828299                                                 | #FFFFFF                                                 |
| seen.background                         | #F5F8FA                                                 | #23232B                                                 |
| seen.timeMarkFontColor                  | #BEBECC                                                 | #525266                                                 |
| unseen.fontColor                        | #828299                                                 | #FFFFFF                                                 |
| unseen.background                       | #FFFFFF                                                 | #292933                                                 |
| unseen.boxShadow                        | 0px 5px 15px rgba(122, 133, 153, 0.25)                  | 0px 5px 20px rgba(0, 0, 0, 0.2)                         |
| unseen.notificationItemBeforeBrandColor | linear-gradient(0deg,#FF512F 0%,#DD2476 100%)           | linear-gradient(0deg,#FF512F 0%,#DD2476 100%)           |
| unseen.timeMarkFontColor                | #828299                                                 | #828299                                                 |
| buttons.primary.backGroundColor         | linear-gradient(99deg,#DD2476 0% 0%, #FF512F 100% 100%) | linear-gradient(99deg,#DD2476 0% 0%, #FF512F 100% 100%) |
| buttons.primary.fontColor               | #FFFFFF                                                 | #FFFFFF                                                 |
| buttons.primary.removeCircleColor       | white                                                   | white                                                   |
| buttons.primary.fontFamily              | inherit                                                 | inherit                                                 |
| buttons.secondary.backGroundColor       | #F5F8FA                                                 | #3D3D4D                                                 |
| buttons.secondary.fontColor             | #525266                                                 | #FFFFFF                                                 |
| buttons.secondary.removeCircleColor     | #525266                                                 | #525266                                                 |
| buttons.secondary.fontFamily            | inherit                                                 | inherit                                                 |

#### `IThemeActionsMenu`

| Property        | Default Value (Light Theme) | Default Value - (Dark Theme) |
| --------------- | --------------------------- | ---------------------------- |
| dotsButtonColor | #A1A1B2                     | #525266                      |
| dropdownColor   | #FFFFFF                     | #292933                      |
| hoverColor      | #F5F8FA                     | #3D3D4D                      |
| fontColor       | #525266                     | #FFFFFF                      |

#### `IThemeUserPreferences`

| Property                                   | Default Value (Light Theme)                   | Default Value - (Dark Theme)                  |
| ------------------------------------------ | --------------------------------------------- | --------------------------------------------- |
| `settingsButtonColor`                      | #A1A1B2                                       | #525266                                       |
| `accordion.background`                     | #FFFFFF                                       | #292933                                       |
| `accordion.fontColor`                      | #525266                                       | #FFFFFF                                       |
| `accordion.secondaryFontColor`             | #828299                                       | #828299                                       |
| `accordion.boxShadow`                      | 0px 5px 15px rgba(122, 133, 153, 0.25)        | 0px 5px 20px rgba(0, 0, 0, 0.2)               |
| `accordion.arrowColor`                     | #828299                                       | #828299                                       |
| `accordion.arrowColor`                     | #EDF0F2                                       | #3D3D4D                                       |
| `accordionItem.fontColor.active`           | #525266                                       | #FFFFFF                                       |
| `accordionItem.fontColor.inactive`         | #BEBECC                                       | #828299                                       |
| `accordionItem.icon.active`                | #525266                                       | #FFFFFF                                       |
| `accordionItem.icon.inactive`              | #BEBECC                                       | #525266                                       |
| `accordionItem.switch.backgroundChecked`   | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) |
| `accordionItem.switch.backgroundUnchecked` | #BEBECC                                       | #3D3D4D                                       |
| `footer.logoTextColor`                     | #000000                                       | #FFFFFF                                       |
| `footer.logoPrefixFontColor`               | #A1A1B2                                       | #525266                                       |
| `loaderColor`                              | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) | linear-gradient(0deg,#FF512F 0%,#DD2476 100%) |

#### `IThemeFooter`

| Property            | Default Value (Light Theme) | Default Value - (Dark Theme) |
| ------------------- | --------------------------- | ---------------------------- |
| logoTextColor       | #000000                     | #FFFFFF                      |
| logoPrefixFontColor | #A1A1B2                     | #525266                      |

customization properties

| Property                   | type                                      | Default Value (Light Theme) | Default Value - (Dark Theme) |
| -------------------------- | ----------------------------------------- | --------------------------- | ---------------------------- |
| colorScheme                | string                                    | light                       | light                        |
| unseenBadgeColor           | string or [ISvgStopColor](#isvgstopcolor) | -                           | -                            |
| unseenBadgeBackgroundColor | string                                    | #FFFFFF                     | #1E1E26                      |

#### `ISvgStopColor`

| Property        | Default Value (Light Theme) | Default Value - (Dark Theme) |
| --------------- | --------------------------- | ---------------------------- |
| stopColor       | #FF512F                     | #FF512F                      |
| stopColorOffset | #DD2476                     | #DD2476                      |

## Others

### The notification `IMessage` model

`IMessage` model has the following properties:

| Property                  | Type                                      | Description                                                                                          |
| ------------------------- | ----------------------------------------- | ---------------------------------------------------------------------------------------------------- |
| \_id                      | string                                    | A unique Novu message identifier                                                                     |
| channel                   | [ChannelTypeEnum](#channeltypeenum)       | Use to specify the actual channel of this message (in\_app will be used here)                        |
| seen                      | boolean                                   | Whether the notification item was read by the user, changed when the user clicks on the notification |
| lastSeenDate              | ISODate                                   | When the user has last seen the notification                                                         |
| content                   | string                                    | An HTML string of the generated notification content with parsed and replaced variables              |
| templateIdentifier        | string                                    | A unique Novu workflow identifier                                                                    |
| payload                   | `Record<string, unknown>`                 | The payload object that was passed to the trigger even of the workflow.                              |
| createdAt                 | ISODate                                   | The creation date of the message                                                                     |
| cta.type                  | [ChannelCTATypeEnum](#channelctatypeenum) | The type of the CTA specified in the admin panel                                                     |
| cta.data.url              | string                                    | The redirect URL set in the admin panel, can be used to navigate on notification click               |
| cta.action.status         | boolean                                   | Indication whether the action occurred                                                               |
| cta.action.buttons        | [IMessageButton\[\]](#imessagebutton)     | Array of action buttons                                                                              |
| cta.action.result.payload | `Record<string, unknown>`                 | Payload object that send on updateAction method in useNotifications hook                             |
| cta.action.result.type    | [ButtonTypeEnum](#buttontypeenum)         | Type of the button                                                                                   |
| subscriber                | [SubscriberProps](#subscriberprops)       | Subscriber object that contains information about the subscriber                                     |

### SubscriberProps

| Property     | Type   | Description                                                         |
| ------------ | ------ | ------------------------------------------------------------------- |
| \_id         | string | Auto-generated identifier for the subscriber entity in the database |
| firstName    | string | First name of the subscriber                                        |
| subscriberId | string | identifier of the subscriber entity in the Novu Web Dashboard       |

### IMessageButton

| Property | Type                              | Description       |
| -------- | --------------------------------- | ----------------- |
| type     | [ButtonTypeEnum](#buttontypeenum) | Button type enum  |
| content  | string                            | Button inner text |

### ChannelCTATypeEnum

| Property | Value    |
| -------- | -------- |
| REDIRECT | redirect |

### ChannelTypeEnum

| Property | Value   |
| -------- | ------- |
| IN\_APP  | in\_app |
| EMAIL    | email   |
| SMS      | sms     |
| CHAT     | chat    |
| PUSH     | push    |

### ButtonTypeEnum

| Property  | Value     |
| --------- | --------- |
| PRIMARY   | primary   |
| SECONDARY | secondary |


# Customizing Notification Center
Source: https://v0.x-docs.novu.co/notification-center/client/react/customization

Learn how to customize the pre built notification center component partially or building your own notification center component from scratch using Novu provided hooks

## PopoverNotificationCenter Customization

`<PopoverNotificationCenter>` is a pre built notification center component that can be used to show notifications in your application. It is a popover component that can be placed anywhere in your application. A bell will appear on the page. On click of that bell, a popover will appear. Checkout all customizations and available [props](/notification-center/client/react/api-reference#popovernotificationcenter). If you are looking for a component without popover use regular `<NotificationCenter>` component. Checkout [props](/notification-center/client/react/api-reference#notificationcenter) of this component. Few selected customization options are explained below:-

### Implementing custom bell icon

It is common that you might have a special set of icons you use within your application and you will want to replace the default: `NotificationBell` coming from our library.

For this you can easily switch the `NotificationBell` with your own bell. Just make sure you pass the `unseenCount` param inside and use it accordingly.

```jsx theme={null}
<PopoverNotificationCenter colorScheme="dark">
  {({ unseenCount }) => (
    <CustomBell
      unseenCount={unseenCount}
      colorScheme="dark"
      unseenBadgeBackgroundColor="#FFFFFF"
      unseenBadgeColor="#FF0000"
    />
  )}
</PopoverNotificationCenter>
```

### Dark mode support

To support dark mode in your application the notification center component can receive a `colorScheme` prop that can receive either `dark` or `light` mode.

```tsx theme={null}
<PopoverNotificationCenter colorScheme={"dark" || "light"}>
  {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
</PopoverNotificationCenter>
```

### Popover positioning

Use `position`  and `offset` prop to position the popover relative to the Bell icon

```jsx theme={null}
<PopoverNotificationCenter position="left-start" offset={20}>
  {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
</PopoverNotificationCenter>
```

### Header, Footer and Empty state

Use `header`, `footer` and `emptyState` prop to customize the header, footer and empty state of notification center.

```jsx theme={null}
const Header = () => {
  return <span> My custom header </span>;
};

const Footer = () => {
  return <span> My custom footer </span>;
};

const EmptyState = () => {
  return <span> My custom empty state </span>;
};

<PopoverNotificationCenter
  colorScheme="dark"
  header={() => <Header />}
  footer={() => <Footer />}
  emptyState={<EmptyState />}
>
  {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
</PopoverNotificationCenter>;
```

### Notification item

Use the listItem prop to show custom notification items.

```jsx theme={null}
<PopoverNotificationCenter
  colorScheme={colorScheme}
  onNotificationClick={handlerOnNotificationClick}
  onActionClick={handlerOnActionClick}
  listItem={(
    notification,
    handleActionButtonClick,
    handleNotificationClick
  ) => {
    return (
      <a
        href="/"
        onClick={(e) => {
          e.preventDefault();
          handleNotificationClick();
        }}
      >
        {notification.content}
      </a>
    );
  }}
>
  {({ unseenCount }) => {
    return <NotificationBell unseenCount={unseenCount} />;
  }}
</PopoverNotificationCenter>
```

### Customize the UI language

If you want to use a language other than english for the UI, the `NovuProvider` component can accept an optional `i18n` prop.

```typescript theme={null}
<NovuProvider
  subscriberId={"USER_ID"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
  i18n="en"
>
  <PopoverNotificationCenter colorScheme="dark">
    {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
  </PopoverNotificationCenter>
</NovuProvider>
```

The `i18n` prop can accept 2 different types of values

* 2 letter language string

```typescript theme={null}
i18n = "en";
```

<Accordion title="Supported Language">
  * `af` (Afrikaans)
  * `am` (Amharic)
  * `ar` (Arabic)
  * `as` (Assamese)
  * `az` (Azerbaijani)
  * `ba` (Bashkir)
  * `be` (Belarusian)
  * `bg` (Bulgarian)
  * `bh` (Bihari)
  * `bn` (Bengali)
  * `bs` (Bosnian)
  * `ca` (Catalan)
  * `cs` (Czech)
  * `da` (Danish)
  * `de` (German)
  * `el` (Greek)
  * `en` (English)
  * `es` (Spanish)
  * `eu` (Basque)
  * `fa` (Farsi)
  * `fi` (Finnish)
  * `fr` (French)
  * `ga` (Irish)
  * `gl` (Galician)
  * `gu` (Gujarati)
  * `he` (Hebrew)
  * `hi` (Hindi)
  * `hr` (Croatian)
  * `hu` (Hungarian)
  * `hy` (Armenian)
  * `id` (Indonesian)
  * `ig` (Igbo)
  * `it` (Italian)
  * `ja` (Japanese)
  * `ka` (Kannada)
  * `kk` (Kazakh)
  * `km` (Khmer)
  * `ko` (Korean)
  * `ku` (Kurdish)
  * `lo` (Lao)
  * `lt` (Lithuanian)
  * `lv` (Latvian)
  * `ml` (Malayalam)
  * `mr` (Marathi)
  * `ms` (Malay)
  * `nb` (Norwegian)
  * `ne` (Nepali)
  * `nl` (Dutch)
  * `or` (Odia)
  * `pa` (Punjabi)
  * `pl` (Polish)
  * `pt` (Portuguese)
  * `ro` (Romanian)
  * `ru` (Russian)
  * `sa` (Sanskrit)
  * `sd` (Sindhi)
  * `si` (Sinhala)
  * `sm` (Samoan)
  * `sq` (Albanian)
  * `sv` (Swedish)
  * `sq` (Albanian)
  * `ta` (Tamil)
  * `te` (Telugu)
  * `th` (Thai)
  * `tl` (Tagalog)
  * `tr` (Turkish)
  * `uk` (Ukrainian)
  * `ur` (Urdu)
  * `uz` (Uzbek)
  * `vi` (Vietnamese)
  * `zh` (Chinese)
  * `zu` (Zulu)
</Accordion>

* Translation object

```typescript theme={null}
i18n={{
  // Make sure that the following is a proper language code,
  // since this is used by Intl.RelativeTimeFormat in order to calculate the relative time for each notification
  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
  lang: "de",

  translations: {
    poweredBy: "von",
    markAllAsRead: "Alles als gelesen markieren",
    notifications: "Benachrichtigungen",
    settings: "Einstellungen",
  },
}}

```

<Tip>Novu uses *`en`* as the default value for i18n</Tip>

### Customization using `styles` prop

`styles` prop can be used to cutomise styling of each component of notification center. Read more about [styles prop](/notification-center/client/react/api-reference#styles)

```javascript theme={null}
export const styles = {
  bellButton: {
    root: {
      marginTop: "20px",
      svg: {
        color: "#AFE1AF",
        fill: "white",
        minWidth: "20px",
        minHeight: "20px"
      }
    },
    dot: {
      rect: {
        fill: "white",
        strokeWidth: "0",
        width: "3px",
        height: "3px",
        x: 10,
        y: 2
      }
    }
  }
}
```

<Accordion title="Customizing styles">
  ```javascript theme={null}
  const primaryColor = "white";
  const secondaryColor = "#AFE1AF";
  const primaryTextColor = "#0C0404";
  const secondaryTextColor = "#494F55";
  const unreadBackGroundColor = "#869F9F";
  const primaryButtonBackGroundColor = unreadBackGroundColor;
  const secondaryButtonBackGroundColor = "#C6DFCD";
  const dropdownBorderStyle = "2px solid #AFE1AF";
  const tabLabelAfterStyle = "#AFE1AF !important";
  const ncWidth = "350px !important";

  export const styles = {
    bellButton: {
      root: {
        marginTop: "20px",
        svg: {
          color: secondaryColor,
          fill: primaryColor,
          minWidth: "20px",
          minHeight: "20px"
        }
      },
      dot: {
        rect: {
          fill: primaryColor,
          strokeWidth: "0",
          width: "3px",
          height: "3px",
          x: 10,
          y: 2
        }
      }
    },
    unseenBadge: {
      root: { color: primaryTextColor, background: secondaryColor }
    },
    popover: {
      root: { zIndex: -99 },
      arrow: {
        backgroundColor: primaryColor,
        borderLeftColor: secondaryColor,
        borderTopColor: secondaryColor
      },
      dropdown: {
        border: dropdownBorderStyle,
        borderRadius: "10px",
        marginTop: "25px",
        maxWidth: ncWidth
      }
    },
    header: {
      root: {
        backgroundColor: primaryColor,
        "&:hover": { backgroundColor: primaryColor },
        cursor: "pointer",
        color: primaryTextColor
      },
      cog: { opacity: 1 },
      markAsRead: {
        color: primaryTextColor,
        fontSize: "14px"
      },
      title: { color: primaryTextColor },
      backButton: {
        color: primaryTextColor
      }
    },
    layout: {
      root: {
        background: primaryColor,
        maxWidth: ncWidth
      }
    },
    loader: {
      root: {
        stroke: primaryTextColor
      }
    },
    accordion: {
      item: {
        backgroundColor: secondaryColor,
        ":hover": {
          backgroundColor: secondaryColor
        }
      },
      content: {
        backgroundColor: secondaryColor,
        borderBottomLeftRadius: "7px",
        borderBottomRightRadius: "7px"
      },
      control: {
        ":hover": {
          backgroundColor: secondaryColor
        },
        color: primaryTextColor,
        title: {
          color: primaryTextColor
        }
      },
      chevron: {
        color: primaryTextColor
      }
    },
    notifications: {
      root: {
        ".nc-notifications-list-item": {
          backgroundColor: secondaryColor
        }
      },
      listItem: {
        layout: {
          borderRadius: "7px",
          color: primaryTextColor,
          "div:has(> .mantine-Avatar-root)": {
            border: "none",
            width: "20px",
            height: "20px",
            minWidth: "20px"
          },
          ".mantine-Avatar-root": {
            width: "20px",
            height: "20px",
            minWidth: "20px"
          },
          ".mantine-Avatar-image": {
            width: "20px",
            height: "20px",
            minWidth: "20px"
          }
        },
        timestamp: { color: secondaryTextColor, fontWeight: "bold" },
        dotsButton: {
          path: {
            fill: primaryTextColor
          }
        },
        unread: {
          "::before": { background: unreadBackGroundColor }
        },
        buttons: {
          primary: {
            background: primaryButtonBackGroundColor,
            color: primaryTextColor,
            "&:hover": {
              background: primaryButtonBackGroundColor,
              color: secondaryTextColor
            }
          },
          secondary: {
            background: secondaryButtonBackGroundColor,
            color: secondaryTextColor,
            "&:hover": {
              background: secondaryButtonBackGroundColor,
              color: secondaryTextColor
            }
          }
        }
      }
    },
    actionsMenu: {
      item: { "&:hover": { backgroundColor: secondaryColor } },
      dropdown: {
        backgroundColor: primaryColor
      },
      arrow: {
        backgroundColor: primaryColor,
        borderTop: "0",
        borderLeft: "0"
      }
    },
    preferences: {
      item: {
        title: { color: primaryTextColor },
        divider: { borderTopColor: primaryColor },
        channels: { color: secondaryTextColor },
        content: {
          icon: { color: primaryTextColor },
          channelLabel: { color: primaryTextColor },
          success: { color: primaryTextColor }
        }
      }
    },
    tabs: {
      tabLabel: {
        "::after": { background: tabLabelAfterStyle },
        ":hover": { color: tabLabelAfterStyle },
        "[data-active]": { color: tabLabelAfterStyle }
      },
      tabsList: { borderBottomColor: primaryColor }
    }
  };
  ```
</Accordion>

[![Edit custom-styles-novu-nc](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/custom-styles-novu-nc-2jd46m?fontsize=14\&module=%2Fsrc%2Fstyles.js\&moduleview=1\&theme=dark)

## Customization Using Hooks

If you don't want to use our pre built component then, you can build your own notification center using hooks. `@novu/notification-center` react package provides many hooks like `useNotifications`, `useFetchNotifications`, `useUpdateUserPreferences`. Checkout all available [hooks](/notification-center/client/react/api-reference#hooks). All the hooks should be defined inside the [NovuProvider](/notification-center/client/react/api-reference#novuprovider) component. Most of the hooks are based on the `@tanstack/react-query` library.

Checkout below example on how to use `useNotifications` and `useFetchNotifications` hook
[![Edit useNotifications-useFetchNotifications-hook](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/usenotifications-usefetchnotifications-hook-2t6sgz?fontsize=14\&hidenavigation=1\&theme=dark)


# React Get Started
Source: https://v0.x-docs.novu.co/notification-center/client/react/get-started

Learn how to add novu powered In-App notification center to your React app

Novu provides the `@novu/notification-center` a React library that helps to add a fully functioning notification center to your web application in minutes. Let's do a quick recap on how you can easily use it in your application.

1. Install `@novu/notification-center` npm package in your react app

```jsx theme={null}
npm install @novu/notification-center
```

2. Add the below code in the app.tsx file

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
  IMessage,
} from "@novu/notification-center";

function Novu() {
  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <PopoverNotificationCenter colorScheme="dark">
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}
```

[![Edit kind-nova-xv6s9g](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark)

Go to this react app browser tab, there will be a bell icon. On clicking that bell icon, you will see a notification component popover

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Use your own backend and socket URL

By default, Novu's hosted services of API and socket are used. If you want, you can override them and configure your own.

```tsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
} from "@novu/notification-center";

function Novu() {
  return (
    <NovuProvider
      backendUrl={"YOUR_BACKEND_URL"}
      socketUrl={"YOUR_SOCKET_URL"}
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <PopoverNotificationCenter colorScheme="dark">
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}
```

## Notification center without bell

If you don't want to show the bell icon, you can directly render the notification center component without passing the bell, use `<NotificationCenter>` component in place of `<PopoverNotificationCenter>`

```jsx theme={null}
import {
  NovuProvider,
  NotificationCenter,
} from "@novu/notification-center";

<NovuProvider
  subscriberId={"SUBSCRIBER_ID"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
>
  <NotificationCenter colorScheme="dark" />
</NovuProvider>
```

## HMAC Encryption

When Novu's user adds the notification center to their application they are required to pass a `subscriberId` which identifies the user's end-customer, and the application Identifier which is acted as a public key to communicate with the notification feed API.

A malicious actor can access the user feed by accessing the API and passing another `subscriberId` using the public application identifier.

HMAC encryption will make sure that a `subscriberId` is encrypted using the secret API key, and those will prevent malicious actors from impersonating users.

### Enabling HMAC Encryption

In order to enable Hash-Based Message Authentication Codes, you need to visit the admin panel In-App settings page and enable HMAC encryption for your environment.

<Frame>
  <img />
</Frame>

1. Next step would be to generate an HMAC encrypted subscriberId on your backend:

```jsx theme={null}
import { createHmac } from "crypto";

const hmacHash = createHmac("sha256", process.env.NOVU_API_KEY)
  .update(subscriberId)
  .digest("hex");
```

2. Then pass the created HMAC to your client side application forward it to the component:

```jsx theme={null}
<NovuProvider
  subscriberId={"SUBSCRIBER_ID_PLAIN_VALUE"}
  subscriberHash={"SUBSCRIBER_ID_HASH_VALUE"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
>
  <NotificationCenter colorScheme="dark" />
</NovuProvider>
```

<Info>If HMAC encryption is active in In-App provider settings and  `subscriberHash` along with `subscriberId` is not provided, then notification center will not load</Info>

## Notification Actions

### onNotificationClick

This function is invoked when the user clicks anywhere on the notification except for CTA actions.

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
  IMessage,
} from "@novu/notification-center";

function Novu() {
  function handleOnNotificationClick(message: IMessage) {
    // your logic to handle the notification click
    if (message?.cta?.data?.url) {
      window.location.href = message.cta.data.url;
    }
  }

  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <PopoverNotificationCenter
        colorScheme="dark"
        onNotificationClick={handleOnNotificationClick}
      >
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}
```

### onActionClick

This function is invoked when the user clicks on the action CTA buttons of the notification

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  IMessage,
  MessageActionStatusEnum,
  useUpdateAction,
  ButtonTypeEnum,
  NotificationBell,
} from "@novu/notification-center";

export default function Novu() {

  const CustomNotificationCenter = () => {
    const { updateAction } = useUpdateAction();

    const handleOnActionClick = async (
      templateIdentifier: string,
      btnType: ButtonTypeEnum,
      notification: IMessage
    ) => {
      if (templateIdentifier === "friend-request") {
        if (btnType === "primary") {
          /** Call your API to accept the friend request here **/

          /** And then update Novu that this action has been taken, so the user won't see the button again **/
          updateAction({
            messageId: notification._id,
            actionButtonType: btnType,
            status: MessageActionStatusEnum.DONE,
          });
        }
      }
    };

    return (
      <PopoverNotificationCenter
        colorScheme={"dark"}
        onActionClick={handleOnActionClick}
      >
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    );
  };

  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <CustomNotificationCenter />
    </NovuProvider>
  );
}
```

<Note>CTA buttons text and redirect url field supports dynamic variables</Note>

## Avatar Icons

Avatar images can be shown with in-app notifications. To do so, enable `Add an Avatar` option in in-app step editor as shown below

<Frame>
  <img />
</Frame>

**There are 3 ways to show the avatar images in the notifications:**

<Frame>
  <img />
</Frame>

### User Avatar

This option will show the avatar of the actor user. actor field can be sent while triggering the worklfow. Each subscriber has `avatar` field. For this option to work actor should have `avatar` field set with valid publicly accessible image URL. If the actor doesn't have `avatar` field, then the default avatar will be shown. Worklfow trigger example with avatar

```javascript theme={null}
await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: 'subscriberId_1',
  },
  payload: {
    "key": "value"
  },
  actor: "subscriberId_2"
});
```

Here subscriberId\_2 is used as actor and workflow is triggered to subscriberId\_1

### Static Avatar Url

This option can be used if you want to show same, static and custom avatar icon for each in-app notification of this workflow in-app step. Make sure to toggle off **User Avatar** option to enable this. This is a input field where only valid publicly accessible image URL can be entered. Currently variables are not supported in this field.

### System Avatar Icons

Novu supports 6 system avatar icons. These are default icons that can be selected as avatar icon. Once selected, same icon will be used as avatar icons for all notifications of this in-app step.

## Realtime sockets

Novu provides a real-time socket API for you to consume and get updates about new notifications added to the user's feed. To use the socket connection you can use the `useSocket` hook provided by the `@novu/notification-center` library. Let's see an example of that:

```tsx theme={null}
import { NovuProvider, useSocket } from "@novu/notification-center";

function Novu() {
  return (
    <NovuProvider
      subscriberId={"SUBSCRIBER_ID"}
      applicationIdentifier={"APPLICATION_IDENTIFIER"}
    >
      <CustomNotificationCenter />
    </NovuProvider>
  );
}

function CustomNotificationCenter() {
  const { socket } = useSocket();

  useEffect(() => {
    if (socket) {
      socket.on("notification_received", (data) => {
        console.log(data);
      });
    }

    return () => {
      if (socket) {
        socket.off("notification_received");
      }
    };
  }, [socket]);

  return <></>;
}
```

There are three sockets events available:

1. `unseen_count_changed`
2. `unread_count_changed`
3. `notification_received`

### Toast notification

Novu does not have a native toast component. However, if your project is using any UI library like chakra, material-ui, mantine then toast component (snackbar in case of material-ui) of these libraries can be used with `useSocket` hook. Add the toast opening code in `socket.on` callback.

```javascript toast.tsx theme={null}
socket.on("notification_received", (data) => {
  console.log(data);
  // set received notification content as toast content
  setToastContent(data.content)
  // open the toast
  openToast(true)
});
```

## Example

[![Edit kind-nova-xv6s9g](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark)

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="The notification center is not loading properly.">
    Possible reasons for the notification center not loading properly:

    * Invalid subscriberId
    * Invalid applicationIdentifier
    * Invalid subscriberHash (in case of active HMAC encryption)
    * Invalid backendUrl (in case of self-hosted)
    * Invalid socketUrl (in case of self-hosted)
  </Accordion>

  <Accordion title="There is a render error due to the notification center in React.">
    The notification center should be wrapped in `<NovuProvider>`
  </Accordion>

  <Accordion title="What is the difference between a redirect URL and CTA?">
    The redirect URL is for the entire notification item, When the user clicks the notification, the user will be routed to that url. CTA are two call-to-action buttons. `onNotificationClick` function prop is used for redirecting url and the `onActionClick` function prop is used for CTA.
  </Accordion>

  <Accordion title="Can bell icon in Novu dashboard be used for in-app channel testing?">
    Bell icon and notification center in Novu dashboard is only for receiving system related notifications like user you invited has joined, password reset request sent. It can not to used to test notification center. Consider using our [codesandbox example](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark) instead.
  </Accordion>

  <Accordion title="How to fix CORS error with notification center?">
    Our notification center is configures for all hosts. Please disable root level `withCredentials` config in axios or fetch http requests.
  </Accordion>
</AccordionGroup>


# Configuring Multiple Tabs
Source: https://v0.x-docs.novu.co/notification-center/client/react/multiple-tabs



Novu allows to create a multi-tab experience for a notification center, in a way you can fetch the notifications feed using a filtered query.

### Defining stores

To create multiple stores you can use the prop `stores` on the `NovuProvider` component. Each store has `storeId` property that will be used to interact with information related to this store.

```tsx theme={null}
<NovuProvider
  stores={[
    /**
	storeId and feedIdentifier must be identical and should be copied from In-App editor feed
  */
    {
      storeId: "product-updates",
      query: { feedIdentifier: "product-updates" },
    },
    { storeId: "user-activity", query: { feedIdentifier: "user-activity" } },
  ]}
  subscriberId={"SUBSCRIBER_ID"}
  applicationIdentifier={"APPLICATION_IDENTIFIER"}
>
  <PopoverWrapper />
</NovuProvider>
```

Using the `query` object multiple fields can be passed for feed API:

* `feedIdentifier` - Can be configured and created on the WEB UI
* `seen` - Identifies if the notification has been seen or not

After specifying the `stores` prop, you can use the `storeId` property to interact with the store.

### Managing feeds on the web UI

1. How to add a new feed or select existing feed for In-App step?

To add a new feed, enable *Use Feeds* checkbox in In-App editor. Select from existing feeds or create a new feed by writing in the input field and then clicking on plus icon in the right side.

<Frame>
  <img />
</Frame>

2. How to copy `feedIdentifier` (`storeId`)

To copy `feedIdentifier` (`storeId`) click on the feed name of existing feeds. copy three dot icon. a menu will appear. click on Copy ID option to copy selected feed's `feedIdentifier`

<Frame>
  <img />
</Frame>

<Info>
  By specifying only a storeId, without a query, you could get all notifications.
</Info>

### Using `tabs` prop on the notification center

```tsx theme={null}
<PopoverNotificationCenter
  colorScheme="dark"
  tabs={[
    // name can be any custom name
    { name: "Product Updates", storeId: "product-updates" },
    { name: "User Activity", storeId: "user-activity" },
  ]}
  colorScheme={colorScheme}
  onNotificationClick={handlerOnNotificationClick}
  onActionClick={handlerOnActionClick}
>
  {({ unseenCount }) => {
    return (
      <NotificationBell colorScheme={colorScheme} unseenCount={unseenCount} />
    );
  }}
</PopoverNotificationCenter>
```

<Frame>
  <img />
</Frame>

## Example

[![Edit tabs-in-in\_app](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/tabs-in-in-app-xdk74x?fontsize=14\&hidenavigation=1\&theme=dark)

## Important Links

<CardGroup>
  <Card title="Get all feeds" icon="plug" href="/api-reference/feeds/get-feeds" />

  <Card title="Create a new feed" icon="plug" href="/api-reference/feeds/create-feed" />

  <Card title="Delete a feed" icon="plug" href="/api-reference/feeds/delete-feed" />
</CardGroup>


# Subscriber Preference
Source: https://v0.x-docs.novu.co/notification-center/client/react/preference



By default, Novu will show the subscriber preferences cog icon on the notification center component. If you want to hide it, you can use the prop `showUserPreferences` on the `PopoverNotificationCenter` component.

Users can enable/disable any active channel in the workflow using subscriber preferences

<img />

## Get subscriber preferences

<CodeGroup>
  ```typescript Node.JS theme={null}
  import { Novu } from "@novu/node";

  const novu = new Novu("<NOVU_API_KEY>");

  // 111 is subscriberId
  await novu.subscribers.getPreference("111");
  ```
</CodeGroup>

## Update subscriber preference for a workflow

<CodeGroup>
  ```typescript Node.JS theme={null}
  import { Novu, ChannelTypeEnum } from "@novu/node";

  const novu = new Novu("<NOVU_API_KEY>");

  // enable in_app channel
  await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
    enabled: true,
    channel: { type: ChannelTypeEnum.IN_APP, enabled: true },
  });

  // enable email channel
  await novu.subscribers.updatePreference("subscriberId", "workflowIdentifier", {
    enabled: true,
    channel: { type: ChannelTypeEnum.EMAIL, enabled: true },
  });
  ```
</CodeGroup>

Read more about [subscriber preference](/subscribers/preferences).


# Vue Component
Source: https://v0.x-docs.novu.co/notification-center/client/vue



The `@novu/notification-center-vue` package provides a Vue component wrapper over the Notification Center Web Component that you can use to integrate the notification center into your Vue application.

## Installation

```bash theme={null}
npm install @novu/notification-center-vue
```

<Info>Novu supports only Vue 3.</Info>

## The plugin

The Notification Center Vue plugin can be used to register the `NotificationCenterComponent` as a global component. This is the recommended way to use the component.

```typescript theme={null}
import { createApp } from "vue";
import NotificationCenterPlugin from "@novu/notification-center-vue";
import "@novu/notification-center-vue/dist/style.css";
// your app component
import App from "./App.vue";

createApp(App).use(NotificationCenterPlugin).mount("#app");
```

## Example usage

```html theme={null}
<script lang="ts">
  export default {
    data() {
      return {
        applicationIdentifier: import.meta.env.VITE_NOVU_APPLICATION_IDENTIFIER,
        subscriberId: import.meta.env.VITE_NOVU_SUBSCRIBER_ID,
      };
    },
    methods: {
      sessionLoaded() {
        console.log("Notification Center Session Loaded!");
      },
    },
  };
</script>

<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
  />
</template>
```

By default, the `NotificationCenterComponent` renders the default bell button that opens the notification center when clicked, but it can be customized.

## Custom Bell Button

You can pass the custom bell button component as the default slot to the `NotificationCenterComponent` and it will be used to open the notification center. The `NotificationCenterComponent` also accepts a scoped slot which exposes the `unseenCount` property - the number of unseen notifications counts.

```tsx theme={null}
<script lang="ts">
  export default {
    data() {
      return {
        applicationIdentifier: import.meta.env.VITE_NOVU_APPLICATION_IDENTIFIER,
        subscriberId: import.meta.env.VITE_NOVU_SUBSCRIBER_ID,
      };
    },
    methods: {
      sessionLoaded() {
        console.log('Notification Center Session Loaded!');
      },
    },
  };
</script>

<template>
  <NotificationCenterComponent
    :subscriberId="subscriberId"
    :applicationIdentifier="applicationIdentifier"
    :sessionLoaded="sessionLoaded"
    v-slot="slot"
  >
    <button>Notifications: {{ slot.unseenCount }}</button>
  </NotificationCenterComponent>
</template>
```

## Example

* [Vue Notification Center Example](https://github.com/novuhq/examples/tree/main/vue-notification-center-example)
* [CodeSandBox Link 🔗](https://codesandbox.io/p/sandbox/novu-vue-in-app-88p8vx)

## Props

The `NotificationCenterComponent` accepts the same set of props as the [Web Component](./web-component#properties).

It also accepts an extra prop

| Prop     | Type      | Description                                                                                                                                          |
| -------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| triggers | string\[] | This is an Array of events that controls the underlying popper component's trigger. [Read more here](https://floating-vue.starpad.dev/api/#triggers) |


# Web Component
Source: https://v0.x-docs.novu.co/notification-center/client/web-component



The Notification Center Web Component is a custom element that can be used in any web application. It is built by wrapping the React components and consists from its core the three pieces:  `NovuProvider`,  `PopoverNotificationCenter`, and  `NotificationBell` combined together into one.

## ESM module[](https://docs.novu.co/notification-center/web-component#esm-module)

Make sure that you have installed the `@novu/notification-center` package:

```bash theme={null}
npm install @novu/notification-center
```

Then, import the web component and register it as a custom element:

```tsx theme={null}
import { NotificationCenterWebComponent } from "@novu/notification-center";

customElements.define(
  "notification-center-component",
  NotificationCenterWebComponent
);
```

After that, you can use the web component in your HTML:

```html theme={null}
<!-- HTML -->
<notification-center-component
  style="display: inline-flex"
  application-identifier="APPLICATION_IDENTIFIER"
  subscriber-id="SUBSCRIBER_ID"
></notification-center-component>
<script>
  // here you can attach any callbacks, interact with the Notification Center Web Component API
  let nc = document.getElementsByTagName("notification-center-component")[0];
  nc.onLoad = () => console.log("Notification Center session loaded!");
</script>
```

**Please note:** that the properties are named with a `kebab-case` in the HTML, but depending on the technology you use it might be a `camelCase`, for ex. Vue/Angular props are bound with variables using that convention.

### Example

[CodeSandBox Link 🔗](https://codesandbox.io/s/novu-web-component-esm-rltcr5)

## Bundled version (preview)

Sometimes you might not be able to use the ESM module, for example in the WordPress environment. In that case, you can use the bundled version of the Notification Center Web Component that is available on the CDN.

```html theme={null}
<!DOCTYPE html>
<html lang="en">
  <head>
    ...
    <script src="​https://web-component.novu.co/index.js"></script>
  </head>
  <body>
    <notification-center-component
      style="display: inline-flex"
      application-identifier="APPLICATION_IDENTIFIER"
      subscriber-id="SUBSCRIBER_ID"
    ></notification-center-component>
    <script>
      // here you can attach any callbacks, interact with the web component API
      let nc = document.getElementsByTagName(
        "notification-center-component"
      )[0];
      nc.onLoad = () => console.log("hello world!");
    </script>
  </body>
</html>
```

### Example

[CodeSandBox Link 🔗](https://codesandbox.io/s/novu-web-component-bundled-rgrj5r?file=/index.html)

## Properties

The Notification Center Web Component has a few properties that you can use to customize the behavior of the component. The only required property is `applicationIdentifier`.

If you are using TypeScript, then you might want to check the `NotificationCenterComponentProps` interface.

| Prop                       | Type                                                                                         | Description                                                                                                                                                                                                                                                                                                  |
| -------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| backendUrl                 | string                                                                                       | Custom API location in case of self-hosted version of Novu.                                                                                                                                                                                                                                                  |
| socketUrl                  | string                                                                                       | Custom WebSocket Service location in case of self-hosted version of Novu.                                                                                                                                                                                                                                    |
| subscriberId               | string                                                                                       | The subscriberId is a custom identifier used when identifying your users within the Novu platform.                                                                                                                                                                                                           |
| applicationIdentifier      | string                                                                                       | Is a public identifier used to identify your application, can be found in the Novu Admin panel.                                                                                                                                                                                                              |
| subscriberHash             | string                                                                                       | The hashed subscriber id. [Read more about hmac encryption](/notification-center/client/react/get-started#hmac-encryption).                                                                                                                                                                                  |
| stores                     | object\[]                                                                                    | The array of the store items that are bound with the feed, it's used together with tabs property if you would like to have separate feeds in the notification center. [Read more here](/notification-center/client/react/multiple-tabs)                                                                      |
|                            |                                                                                              |                                                                                                                                                                                                                                                                                                              |
| tabs                       | object\[]                                                                                    | The array of items that do describe the tabs/feeds, they are bound with the stores property. [Read more here](/notification-center/client/react/multiple-tabs).                                                                                                                                              |
| showUserPreferences        | boolean                                                                                      | The flag indicating whether the user preference settings should be visible or not.                                                                                                                                                                                                                           |
| allowedNotificationActions | boolean                                                                                      | The flag indicating whether to show/hide the dots menu for actions performed on a notification.                                                                                                                                                                                                              |
| popoverConfig              | object                                                                                       | The object defining how the popover should be positioned. It's properties are position and offset.                                                                                                                                                                                                           |
| popover                    | object                                                                                       | The object defining how the popover should be positioned. It's properties are position and offset. popover is deprecated, use popoverConfig instead.                                                                                                                                                         |
| theme                      | [INovuTheme](/notification-center/client/react/api-reference#the-theme-interface)            | The object defining the the light/dark styles of the Notification Center component. We discourage you to use this prop to do the styling, instead it's recommended to use the styles property.                                                                                                               |
| styles                     | [NotificationCenterStyles](/notification-center/client/react/api-reference#styles-interface) | The object allows you to define the custom CSS code.                                                                                                                                                                                                                                                         |
| colorScheme                | string                                                                                       | The prop defines which color version of the styles the component should set. The options are light and dark.                                                                                                                                                                                                 |
| i18n                       | object                                                                                       | The object allowing to [customize the UI language](/notification-center/client/react/customization#customize-the-ui-language).                                                                                                                                                                               |
| onLoad                     | function                                                                                     | The callback function that is called when the session is successfully initiated. It receives the first argument object with the organization property. There is a sibling property sessionLoaded that might be used in environments that do not allow to use properties with the prefix on, like in Angular. |
| onNotificationClick        | function                                                                                     | The callback function that is called when the user has clicked on the notification. The first argument it receives is the notification object. There is a sibling property notificationClicked.                                                                                                              |
| onUnseenCountChanged       | function                                                                                     | The callback function that is called when the unseen notifications count changes. The first argument it receives is the number of unseen notifications count. There is a sibling property unseenCountChanged.                                                                                                |
| onActionClick              | function                                                                                     | The callback function that is called when user clicks on one of the notification buttons (primary/secondary). The arguments it receives are: template identifier, button type, and notification object. There is a sibling property actionClicked.                                                           |
| onTabClick                 | function                                                                                     | The callback function that is called when user clicks on the feed tab. The first arguments it receives is the tab object. There is a sibling property tabClicked.                                                                                                                                            |

## Limitations

It's important to note that there are some limitations when using the Web Component compared to the React version:

* You get an all-in-one component
* It doesn't support the `children, header, footer, emptyState, listItem` props
* It's a wrapped react component, which means a bigger bundle size (we are working on it to make it smaller)


# Introduction to Notification Center
Source: https://v0.x-docs.novu.co/notification-center/introduction

Learn more about Novu's Notification Center.

The notification center is a component, also sometimes referred to as a widget that furnishes your web application with a beautiful and smooth In-App notification experience for users.

In-App notifications are different from push notifications in the sense that In-App notifications are consumed by the user in your app itself, whether push notifications are shown on the device level. Read more about [push channel and supported providers.](/channels-and-providers/push/overview)

Novu provides a pre-built, ready-to-use, and customizable UI component. It also allows you to bring your own UI via a headless component which can be used to add In-App notifications to any platform.

<iframe />

## Example

[![Edit kind-nova-xv6s9g](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/kind-nova-xv6s9g?fontsize=14\&hidenavigation=1\&theme=dark)

## Why use the Novu notification center?

* Users can manage subscriber preferences from the notification center itself.
* You want to notify about any product activity related to the user.
* Prebuilt UI component so no need to build UI from scratch.
* Highly customizable as per your product design system.
* Multi-device real-time notification experience powered by web sockets.
* Secure your connection using HMAC encryption.
* Have multi-tabs notification experience.

## Concepts

1. `In-App notification`:- In-App notification is a message sent to the subscriber using an In-App channel step in the workflow.
2. `In-App notifications feed`:- List of all In-App messages sent to a particular subscriber.
3. `feeds`:- feeds are stores/tabs in which In-App messages can be grouped. One message can be in only one feed.
4. `notification actions`:- Notification actions are cta buttons below notification content that can be clicked to perform any action or external API call.
5. `redirect url`:- When a single notification item from the list is clicked then it can be configured to perform an action or redirect to any URL.

## UI Libraries

1. [React](/notification-center/client/react/get-started)
2. [Vue](/notification-center/client/vue)
3. [Angular](/notification-center/client/angular)
4. [Web Component](/notification-center/client/web-component)
5. [Headless](/notification-center/client/headless/get-started)

## Backend SDK Methods

[Backend sdk methods](/notification-center/backend/methods)


# Environments
Source: https://v0.x-docs.novu.co/platform/environments

Learn about environments in Novu

Novu runs all your requests in the context of an environment. By default, Novu creates two environments when your account was just created, `development` and `production`.

## Development environment

The development environment is used for testing purposes and validating notification changes prior to committing them to the production environment.

## Production environment

It will be your live/production environment, you cannot make changes to this environment directly. You will first have to make the changes in the `development` environment and then promote it to `production`. This is a read-only environment.

## Data associated with environments

Novu will separate most of the data associated with your account based on the current accessed environment. This will include:

* Subscribers
* Workflows
* Messages
* Execution logs
* Connected integrations
* Notification feeds
* Brand related assets and settings

Each environment will be accessed using a separate credential set:

* **Application Identifier** - This is a public identifier used in client-side applications to identify your application. It is unique to an environment in an organization and is different from `Provider Identifier`.
* **Provider Identifier** - This is an identifier for a provider in a channel. For example, say you're using email notifications. Here, two different providers will have two different `Provider Identifier`. Even if you're using two different integration of the same provider, you'll have two different `Provider Identifier`, each unique to one integration. For example, if you've two slack integrations, they will have two different `Provider Identifier`.
* **API Secret Key** - A secret key used when communicating with the `Novu API` from your backend services.

We suggest configuring these key sets based on your active environment, the same as you would use to manage different service credentials and serve them based on the current environment in which your code is deployed.

## Promoting pending changes to production

After making a change to a workflow or brand relating settings, this change will be added under the [changes](https://web.novu.co/changes?utm_campaign=docs-environments) page in the admin panel.

A change is generated by making a difference between the `development` environment and the target `production` environment. All pending changes will be listed on the [changes](https://web.novu.co/changes?utm_campaign=docs-environments) page.

A change can either be applied manually or by pressing the **Promote all changes** button.

<Frame>
  <img />
</Frame>

<br />

<Note> Before pushing a change to production, make sure that the code associated with this change was pushed to production. This is specifically important when adding new variables to a workflow. </Note>

## API Reference Links

* [Get Current Environment API](/api-reference/environments/get-current-environment/)
* [Get API Keys API](/api-reference/environments/get-api-keys/)
* [Regenerate API Keys API](/api-reference/environments/regenerate-api-keys/)


# Inbound Parse Webhook
Source: https://v0.x-docs.novu.co/platform/inbound-parse-webhook

Learn how to process incoming emails for a domain or subdomain

Inbound Webhook is a feature that allows processing of incoming emails for a domain or subdomain.
The feature parses contents of an email and POSTs the information to a specified URL in a `multipart/form-data` format.

<Note>
  This feature is available only in Novu cloud. This feature will not work in community self
  hosted version and local environment.
</Note>

## Steps to set up Inbound Webhook

1. Set up an MX Record:
   * Log in to your domain host's website and navigate to the MX Records page.
   * Create a new MX record for the subdomain you want to process incoming email (e.g. reply.yourdomain.com).
   <Warning>
     You must create a new record for this as this feature does not work if the MX record is already set on the domain.
     Here is an example with [route 53](https://medium.com/@deep_blue_day/how-to-create-a-subdomain-in-amazon-route-53-81918654f5bf)
   </Warning>
   * Assign the MX record a priority of 10 and point it to the specified inbound mail server that located on the admin dashboard on the Email Settings.
     <Info>
       For US, use `inbound-mail.novu.co` and For EU, use
       `eu.inbound-mail.novu.co`
     </Info>
2. Add Domain to allowed list:
   * Log in to the dashboard.
   * Go to the Setting tab in the left vertical navbar.
   * Navigate to Email Settings on the settings page.
   * Add your domain to the allowed domain box.
   <Warning>
     You can only add one Inbound Webhook domain per organization.
   </Warning>
3. Enable Inbound Parse and Set Webhook URL:
   * Log in to the dashboard.
   * Navigate to the Workflow Editor.
   * Select the email step.
   * Enable the Inbound Parse feature.
   * Set the Webhook URL to the location where you want the parsed data to be POSTed.

<Note>The Webhook URL must be publicly accessible without authentication.</Note>


# Webhooks for Providers
Source: https://v0.x-docs.novu.co/platform/webhooks-for-providers

Learn how to setup webhook support for a provider.

Novu provides a URL that you can use to setup webhook support for your integrated provider.

This enables to receive much more detailed information from the provider about the outgoing messages in the [Activity Feed](/activity-feed/introduction) section.

Currently, only `Email` and `SMS` channels are supported with limited providers. Support for more providers will be added in future.

<Note>
  This feature is available only in Novu cloud. This feature will not work in community self
  hosted version and local environment.
</Note>

## Get your Webhook URL

To get your provider specific webhook URL, follow the below steps:

* Open your already connected provider from the `Integration Store` page.
* Scroll down the modal to find the `Webhook URL` field.
* Copy the given URL to configure it on the provider's webhook setup page.

<Frame>
  <img />
</Frame>

<br />

<Note> Webhook URL will only be visible for connected providers and after you've connected the provider. </Note>

## Supported Providers

* [Mailjet](/channels-and-providers/email/mailjet)
* [Mandrill](/channels-and-providers/email/mandrill)
* [Postmark](/channels-and-providers/email/postmark)
* [Sendgrid](/channels-and-providers/email/sendgrid)
* [Sendinblue](/channels-and-providers/email/sendinblue)
* [Telnyx](/channels-and-providers/sms/telnyx)
* [Twilio](/channels-and-providers/sms/twilio)


# Security and Compliance
Source: https://v0.x-docs.novu.co/security-and-compliance/security

Common questions related to security, compliance, privacy policy and terms and conditions

### What should I do if I have regulatory or security issues with PII?

We regularly work with big companies and are happy to help and support you with guidance, and various compliances including reports to ease your security and legal team. If you have concerns about PII, you can use our OS version, Novu Hybrid-Cloud enterprise plan, or reach out to us at [sales@novu.co](mailto:sales@novu.co), [support@novu.co](mailto:support@novu.co), or Discord.

### I need my data to reside in the EU, can it be done?

Yes, as part of our GDPR compliance we have our cloud version available on both EU (Frankfurt), as well as US (Virginia).

### Are you GDPR compliant?

Yes, you can see the complete compliance report on our [security page](https://trust.novu.co/). Novu also decided to take the extra step and provide separate data residency in both the EU and the US.

### I created my account in the EU/US, can I switch to the other one?

Not exactly, to keep data residency intact we cannot simply copy or move data between data warehouses across US and EU. However if you have the need please contact us at [sales@novu.co](mailto:sales@novu.co)

### Are you SOC 2 compliant?

Yes, Novu Cloud is SOC 2 Type II compliant, we have made sure to do penetration tests, security training, evidence collection, and SDL. You can see live control updated on our [security page](https://trust.novu.co/), and ask for our security report as well at [sales@novu.co](mailto:sales@novu.co).

### Are you ISO 27001 compliant?

Yes, Novu Cloud is ISO27001 compliant, we have made sure to go through both Stage 1 and Stage 2 audits, and fully define ISMS requirements. From entirely creating our organization processes, defining organization risk assessment policies, and building organization Incident Response & Disaster Recovery plans.

### Where is my data stored?

Based on the selected solution there are a couple of options. On the OS option based on where you choose to store it :) As to the Novu Cloud solution, you can choose the EU (Frankfurt) or the US (Virginia). In case you are working on the Novu Hybrid-Cloud solution we will help you deploy your data inside your select network.

### For how long user data is stored?

By default, data is stored using the following TTL values

* Notifications (for 1 month)
* Jobs (for 1 month)
* Message (for in-app messages - 12 months, for all other messages - 1 month)
* Execution Details (for 1 month)
* Subscribers, Workflows, Feeds, Layouts (Not deleted automatically, can be deleted by the user at any time)

If you want to delete any specific data or information, reach out to us at [support@novu.co](mailto:support@novu.co)

### How to report any vulnerability or security issue?

We are equally committed to our users and their data’s security. We highly appreciate it if someone shares security vulnerabilities with us. Feel free to use the [github issue](https://github.com/novuhq/novu/security/advisories/new) or email us at [security@novu.co](mailto:security@novu.co).


# AWS
Source: https://v0.x-docs.novu.co/self-hosting-novu/aws

Learn how to deploy Novu to AWS

Amazon Web Services (AWS) is a cloud computing platform by Amazon, providing a wide range of on-demand services like computing power, storage, and databases over the internet.
It enables businesses and individuals to avoid managing physical infrastructure and offers features for computing, storage, databases, analytics, machine learning, and more.
AWS is known for its scalability, flexibility, and global network of data centers.
Learn more about [AWS](https://docs.aws.amazon.com/)

## Deploying on EC2 with the Docker Compose File

Deploying Novu on EC2 with Docker Compose involves several steps.

In general, the steps are as follows:

1. **Set up an EC2 Instance**: Create an instance on AWS EC2. We reccomend a bare minimum of 4 CPU Cores and 16GB of RAM.
2. **Install Docker**: Once you have your instance up and running, SSH into it and install Docker. You can do this by running the following commands:

```bash theme={null}
sudo yum update -y sudo amazon-linux-extras install docker;
sudo service docker start sudo usermod -a -G docker
ec2-user
```

3. **Install Docker Compose**: Docker Compose will allow you to easily manage your application which will consist of multiple Docker containers.
   Install it by running:

```bash theme={null}
sudo curl -L "https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose;
sudo chmod +x /usr/local/bin/docker-compose
```

4. **Deploy Novu**: Now, clone the Novu repository and navigate to the directory containing the docker-compose.yml file.
   To start your Novu instance, simply run:

```bash theme={null}
docker-compose up -d
```

Please note, there are user reports indicating an issue with volume persistence when deploying Novu on EC2 with Docker Compose.
You can see the discussions about this problem [here](https://github.com/novuhq/novu/issues/3339) as we do not provide official support for these types of deployments.
This is something to be aware of when deploying in this manner, and you may need to adopt additional strategies for data persistence.
Be sure to consult the Novu documentation as well as any relevant EC2 and Docker documentation for any necessary details related to your specific deployment needs.
Additionally, keep in mind that these general steps may not cover all nuances or requirements of your particular use case or the specific configuration of the Novu application.
Always ensure any deployment follows best practices for security, scalability, and maintainability.

# 🏗️ This page is still in creation process

We believe in the power of collaboration. If you have insights to share or would like to contribute to the development of this page, we welcome your input. To get involved, follow these steps:

**Open an Issue:** If you've identified an area for improvement or have a suggestion, start by opening an issue in our repository. This allows us to track and discuss the proposed changes.

**Create a Pull Request (PR):** Once you're ready to contribute, fork our repository and create a branch. Implement your changes within this branch and submit a pull request to our **Staging branch**.

By following these steps, you're helping us enhance the quality and depth of our resources. We appreciate your effort in making this page an even more valuable asset.

Your contributions drive progress. Let's build together!


# Deploy with Docker
Source: https://v0.x-docs.novu.co/self-hosting-novu/deploy-with-docker

Learn how to deploy Novu with Docker

Docker compose is the easiest way to get started with self-hosted Novu.

## Before you begin

You need the following installed in your system:

* [Docker](https://docs.docker.com/engine/install/) and [docker-compose](https://docs.docker.com/compose/install/)
* [Git](https://git-scm.com/downloads)

<iframe />

<Info>In above loom video `local/deployment` directory is used. Now it has been moved to `docker/community`. Follow below mentioned steps.</Info>

## Quick Start

### Get the code

Clone the Novu repo and enter the docker directory locally:

```bash theme={null}
# Get the code
git clone --depth 1 https://github.com/novuhq/novu

# Go to the docker community folder
cd novu/docker/community

# Copy the example env file
cp .env.example .env

# Start Novu
docker-compose -f docker-compose.yml up
```

Now visit [http://localhost:4200](http://localhost:4200/) to start using Novu.

## Securing your setup

While we provide you with some example secrets for getting started, you should NEVER deploy your Novu setup using the defaults provided.

Update the `.env` file with your own secrets.

### Required Variables:

* `JWT_SECRET`: Used by the API to generate JWT keys.
* `STORE_ENCRYPTION_KEY`: Used to encrypt/decrypt the provider credentials. It must be 32 characters long.
* `HOST_NAME`: Host name of your installation. This will be the base URL of your installation. For example, if you are deploying to server with ip `35.154.137.80`, then you should set this to `http://35.154.137.80`.

`REDIS_CACHE_SERVICE_HOST` and `REDIS_HOST` can have same value for small deployments. For larger deployments, it is recommended to use separate Redis instances for caching and queue management.

## Configuration

To keep the setup simple, we made some choices that may not be optimal for production:

* the database is in the same machine as the servers
* the storage uses localstack instead of S3

We strongly recommend that you decouple your database before deploying.

### Triggering events with custom installation

When self-hosting Novu, in order to trigger an event you must first create a new `Novu` object and configure it with the proper `backendUrl`.

```tsx theme={null}
import { Novu } from '@novu/node';

const config = {
  backendUrl: '<REPLACE_WITH_BACKEND_URL>',
};

const novu = new Novu('<API_KEY>', config);

await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>',
  },
  payload: {},
});
```

### Pointing IFrame embed to custom installation

When using the IFrame embed to attach the notification center rather than the React component, you need to specify the `backendUrl` and the `socketUrl` when initializing the iframe.

```html theme={null}
<script>
  novu.init(
    '<REPLACE_APPLICATION_ID>',
    {
      unseenBadgeSelector: '#unseen-badge',
      bellSelector: '#notification-bell',
      backendUrl: 'https://api.example.com',
      socketUrl: 'https://ws.example.com',
    },
    {}
  );
</script>

```

### Using React Component with custom installation

See [Use your own backend and socket URL](https://docs.novu.co/notification-center/react/react-components#use-your-own-backend-and-socket-url).

### Caching

We are introducing the first stage of caching in our system to improve performance and efficiency. Caching is turned off by default, but can easily be activated by setting the following environment variables:

* REDIS\_CACHE\_SERVICE\_HOST
* REDIS\_CACHE\_SERVICE\_PORT

Currently, we are caching data in the most heavily loaded areas of the system: the widget requests such as feed and unseen count, as well as common DAL requests during the execution of trigger event flow. These are the most heavily used areas of our system, and we hope that by implementing caching in these areas, we can improve performance in the near future.

### Reverse-Proxy / Load Balancers

To implement a reverse-proxy or load balancer in front of Novu, you need to set the GLOBAL\_CONTEXT\_PATH for the base path of the application.
This is the path that the application will be served from after the domain.
For example:

* company.com/novu
  This is used to set the base path for the application, and is used to set the base path for the API, web, and websocket connections.

The following environment variables are used to set the context path for each public service that Novu provides:
API\_CONTEXT\_PATH
WIDGET\_CONTEXT\_PATH
WS\_CONTEXT\_PATH
WEB\_CONTEXT\_PATH

These allow you to set the context path for each service independently or dependently of the GLOBAL\_CONTEXT\_PATH.

For example, if I was using a reverse proxy to serve Novu from company.com/novu,
I would set the GLOBAL\_CONTEXT\_PATH to novu,
and then set the API\_CONTEXT\_PATH to api,
the WIDGET\_CONTEXT\_PATH to widget,
the WS\_CONTEXT\_PATH to ws,
and the WEB\_CONTEXT\_PATH to web.

This would produce the following urls:

* API: company.com/novu/api
* WIDGET: company.com/novu/widget
* WS: company.com/novu/ws
* WEB: company.com/novu/web

However the Service context path can be used entirely independently of the GLOBAL\_CONTEXT\_PATH.

For example, if I wanted to expose the api as novu-api, I would set the API\_CONTEXT\_PATH to novu-api without setting the GLOBAL\_CONTEXT\_PATH.
This would producte the following url:

* API: company.com/novu-api

<Note> These env variables should be present on all services novu provides due to tight coupling.</Note>


# Introduction
Source: https://v0.x-docs.novu.co/self-hosting-novu/introduction



Self-hosting Novu involves setting up and maintaining your communication infrastructure using your own servers.
While this offers full control and customization,
some features which are available only for Novu’s cloud-managed won't be available in a self-hosted environment.

## Minimum System Requirements

For basic installation, a server with 16GB RAM and 8 CPUs is fine. However, specifications vary depending on requirements and here are sample specifications for handling 1M plus notifications:

* If everything is running on one machine, then at least 36 vCPU and 64GB of RAM.
* If services are running across containers, then it is recommended to run 3 containers per service, each container having 2 vCPU and 4GB of RAM.
* If you're using Kubernetes, then the K8 system needs to have 36 vCPU and 64GB of RAM at least in the cluster to run the servers.
* On AWS, a c6g.8xlarge instance with 32 vCPU and 64GB of RAM.
* In all cases, you need to also have 2 Redis clusters with the queue one having an Append only log file active (AOL) to prevent instances of job loss during an outage,  a MongoDB cluster equivalent to a M20 or greater on Atlas, and 10GB of S3 storage.
* Lastly, the queue Redis instance should be 8GB MINIMUM as there needs to be enough space to handle spikes in notifications or the whole system will brick.

<Note>Note that these specifications are subject to your requirements, the scale of your operations, and should be adjusted as needed.</Note>
<Warning>Github login is not available in self-hosting. If you're self hosting Novu, use your email and password to log into your Novu account!</Warning>


# Kubernetes
Source: https://v0.x-docs.novu.co/self-hosting-novu/kubernetes

Learn how to deploy Novu with K8s

<Warning>
  We do not plan to support any official public kubernetes deployment at this time.
  This guide is to help assist advanced users who want to deploy Novu on their own kubernetes cluster.
</Warning>

Kubernetes is an open-source platform that automates the deployment, scaling, and management of containerized applications.

You can find a community driven [helm deployment](https://github.com/novuhq/novu/blob/next/docker/kubernetes/helm/README.md) in our repository.

## Novu Web Container Does not Run on Kubernetes

Due to the way we build our web container image,
you will need to build your own image and push it to your own registry.
This is due to us compiling the frontend when the container starts.

You can follow our [dev-deploy-web workflow](https://github.com/novuhq/novu/blob/next/.github/workflows/dev-deploy-web.yml)
to see how we build our web container image.
You can also use this workflow to build your own image, you will just need to remove all of the steps after the deploy to netlify step.

<Note>
  Only need to do this IF you do not allow root only access on your cluster.
</Note>


# Object Storage (S3, Blob, GCS)
Source: https://v0.x-docs.novu.co/self-hosting-novu/object-storage

Using S3 as a storage backend for your application

For local development we use [LocalStack.cloud](https://localstack.cloud/). It is utilized as a local emulation of S3 during development.

This might be beneficial for testing and development purposes before transitioning to actual S3 service like in a production environment.

## AWS S3

### Configuration

AWS S3 requires the following environment variables to be set:

1. S3\_REGION:
2. S3\_LOCAL\_STACK (optional): S3 endpoint to connect to, leave blank if your connecting directly to AWS
3. S3\_BUCKET\_NAME: Name of the bucket to use
4. STORAGE\_SERVICE: Name of the storage service to use, 'AWS' or 'LOCALSTACK' for S3.

### Bucket Configuration

In general, access to the S3 bucket is very permissive.

The following process is used to manage access to the S3 bucket.

General design:

* public read access (for logo and email attachments—all data is open for read to anyone)
* write access is via pre-signed url (client-side PUT to S3 after server-side request)
* private write access (get, put, delete)
* objects are written with organisationIdTenancy/objectId (at least for brand logos)

Specifics for access:

* CORS access on bucket (this is documented)
* bucket object do not need versioning (as all uploads are deemed unique)
* ACL on buckets is 'public-read' (as part of the pre-signed URLs)
* image uploads (as pre-signed) could also have rules to limit (DENY policy) on extension types (although UI also does this but leaves open a vector)
* AWS (specific): ensure that Allow owenership controls is 'BucketOwnerPreferred' to allow ACL access (rather than role/user) (ie PutObjectAcl)

### Example Terraform

```terraform theme={null}
/**
 * This sets up an S3 bucket for notifications assets (eg photos, documents). The bucket is
 * PUBLIC for read access and needs to be opened up to the API (which is deployed as an ECS task).
 *
 * It also needs to be opened up to worker (to create pre-signed urls for uploads)
 *
 * This bucket is:
 *  * public read access
 *  * private write access to the credentials (added onto the user rather than onto the bucket)
 */

#
# WARNING: this bucket uses IAM Policies and ACL for access
#
#  - @see https://binaryguy.tech/aws/s3/iam-policies-vs-s3-policies-vs-s3-bucket-acls/#:~:text=The%20biggest%20advantage%20of%20using,well%20as%20objects%20in%20it.
#  - @see https://aws.amazon.com/blogs/security/iam-policies-and-bucket-policies-and-acls-oh-my-controlling-access-to-s3-resources/
#  - @see https://stackoverflow.com/questions/47815526/s3-bucket-policy-vs-access-control-list
#
#
# TF: https://www.terraform.io/docs/providers/aws/r/s3_bucket.html
# AWS: http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/s3api/create-bucket.html
resource "aws_s3_bucket" "notifications" {
  bucket = "${var.environment}-notifications-data"
  # removed for upgrade to aws provider 4.0
  # see https://registry.terraform.io/providers/hashicorp/aws/latest/docs/guides/version-4-upgrade#acl-argument
  # acl    = "private"

  tags = {
    Environment = var.environment
    Terraform   = true
  }
}


# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_public_access_block
resource "aws_s3_bucket_public_access_block" "notifications" {
  bucket                  = aws_s3_bucket.notifications.id
  block_public_acls       = false
  # This feature protects your bucket from accidentally getting a policy that would enable public access
  # We WANT public access for read
  block_public_policy     = false
  ignore_public_acls      = false
  restrict_public_buckets = false
}


# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_ownership_controls
# this is required when setting the 'public-read' acl—without it it fails on apply
resource "aws_s3_bucket_ownership_controls" "notifications" {
  bucket = aws_s3_bucket.notifications.id

  rule {
    object_ownership = "BucketOwnerPreferred"
  }
}

# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_acl
resource "aws_s3_bucket_acl" "notifications" {
  bucket = aws_s3_bucket.notifications.id
  # Defaults to private
  # ["private" "public-read" "public-read-write" "authenticated-read" "aws-exec-read" "log-delivery-write"]
  acl    = "public-read"

  depends_on = [
    aws_s3_bucket_ownership_controls.notifications,
    aws_s3_bucket_public_access_block.notifications,
  ]
}

#
# Note: no point on having vesrioning enabled
#

#
# Restricted CORS policy but increased headers exposed (that could be further restrictred)
#
# TF: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/s3_bucket_cors_configuration
# AWS: https://docs.amplify.aws/lib/storage/getting-started/q/platform/js/#amazon-s3-bucket-cors-policy-setup
resource "aws_s3_bucket_cors_configuration" "notifications" {
  bucket = aws_s3_bucket.notifications.id

  cors_rule {
    allowed_headers = ["*"]
    allowed_methods = [
      "GET",
      "HEAD",
      "PUT",
    ]
    allowed_origins = ["/* OWN FQDN */"]
    expose_headers  = [
      "x-amz-server-side-encryption",
      "x-amz-request-id",
      "x-amz-id-2",
      "x-amz-meta-tag",
      "ETag"
    ]
    max_age_seconds = 3000
  }
}

resource "aws_s3_bucket_policy" "notifications" {
  bucket = aws_s3_bucket.notifications.id
  policy = data.aws_iam_policy_document.notifications-user.json
}

# [Data] IAM policy to define S3 permissions
#
# Restricting users files types to avoid problems (note: hand helds love to upload PDFs)
#
# TF: https://www.terraform.io/docs/providers/aws/d/iam_policy_document.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html
data "aws_iam_policy_document" "notifications-user" {
  statement {
    sid    = "DenyNonImage"
    effect = "Deny"
    principals {
      identifiers = [aws_iam_user.notifications.arn]
      type        = "AWS"
    }
    actions = [
      # NOTE: this is an ACL permissions
      "s3:PutObjectAcl",
    ]
    not_resources = [
      "${aws_s3_bucket.notifications.arn}/*.png",
      "${aws_s3_bucket.notifications.arn}/*.jpg",
      "${aws_s3_bucket.notifications.arn}/*.jpeg",
      "${aws_s3_bucket.notifications.arn}/*.gif"
    ]
  }
  # NOTE: these rules exist on the user policy
/*
  statement {
    effect = "Allow"
    principals {
      type        = "AWS"
      identifiers = [aws_iam_user.notifications.arn]
    }
    actions = [
      "s3:GetObject",
      "s3:DeleteObject",
      "s3:ListBucket",
      "s3:PutObject",
      # this is the magic spice, because the perms are created via ACL (rather than roles)
      "s3:PutObjectAcl"
    ]
    resources = [
      "${aws_s3_bucket.notifications.arn}*/
/*",
    ]
  }
*/
}

#######################

# TF: https://www.terraform.io/docs/providers/aws/r/iam_policy.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html
resource "aws_iam_policy" "s3" {
  name        = "ecs-app-${var.environment}-s3"
  description = "Access from the ecs tasks to s3 buckets"
  policy      = data.aws_iam_policy_document.s3.json
}

# [Data] IAM policy to define S3 permissions
# TF: https://www.terraform.io/docs/providers/aws/d/iam_policy_document.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html
data "aws_iam_policy_document" "s3" {
  statement {
    sid     = ""
    effect  = "Allow"
    actions = [
      "s3:DeleteObject",
      "s3:GetObject",
      "s3:PutObject",
      # this is the magic spice, because the perms are created via ACL (rather than roles)
      "s3:PutObjectAcl",
      "s3:ListBucket"
    ]
    resources = [
      "arn:aws:s3:::${var.assets_bucket}/*"
    ]
  }
}

######################

# Attaches a managed IAM policy to an IAM role for the ecs tasks
# TF: https://www.terraform.io/docs/providers/aws/r/iam_role_policy_attachment.html
# AWS: http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html
# AWS CLI: http://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html
resource "aws_iam_role_policy_attachment" "s3" {
  role       = aws_iam_role.app_task.name  # need your role attached to whatever is doing the execution (eg workload task)
  policy_arn = aws_iam_policy.s3.arn
}
```

## Azure Blob Storage Configuration

### Configuration

Azure Blob Storage requires the following environment variables to be set:

### Required

1. STORAGE\_SERVICE: Name of the storage service to use, 'AZURE' Azure Blob.
2. AZURE\_CONTAINER\_NAME: The name of the container in your Azure Storage account that you wish to use for your blob storage.
3. AZURE\_ACCOUNT\_NAME: The name of your Azure Storage account. This is used to form the URL at which your blob storage is accessible.
4. AZURE\_ACCOUNT\_KEY: The access key for your Azure Storage account. This is used to authenticate requests made against your blob storage.
5. AZURE\_HOST\_NAME: The host name of your Azure Storage account . This is used to form the URL at which your blob storage is accessible. [Ref](https://learn.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-nodejs?tabs=managed-identity%2Croles-azure-portal%2Csign-in-azure-cli#upload-blobs-to-a-container).

### Bucket Configuration

TBD

## Google Cloud Storage Configuration

### Configuration

Google Cloud Storage requires the following environment variables to be set:

1. `GCS_BUCKET_NAME`: Name of the bucket to use.
2. `GOOGLE_APPLICATION_CREDENTIALS`: Path to the service account key file.
3. `STORAGE_SERVICE`: Name of the storage service to use, 'GCS' for Google Cloud Storage.

### Bucket Configuration

TBD


# Tenants
Source: https://v0.x-docs.novu.co/tenants/introduction

Learn all about Tenants

Multi-tenancy is a common use case for a lot of companies that have multiple organizations that use their applications. In some cases, there is a need to separate the behavior of the notification system depending on the individual tenants.

Currently, Novu supports the following customizations:

* Workflow level customizations
* Integration customizations

## Tenant Management

Tenants can be created and modified via the [API](http://docs.novu.co/api-reference/tenants/get-tenants) or [Web](https://web.novu.co/tenants?utm_campaign=docs-tenants). Each tenant can have multiple fields on it:

* Identifier - The identifier is a unique value, and can be used later when pointing to this tenant during trigger calls.
* Name - A human-readable name of the tenant.
* Data - A custom data object that can store information about the tenant. This data can be later accessed inside workflows.

To create a tenant on the Novu web platform, follow these steps:

* Click on `Tenants` on the left sidebar.
* In the Tenants section, click on the `Add a tenant` button.
* Set a `Name` and `Tenant identifier`. The tenant identifier is automatically set once you add a name. However, you can modify it to your needs.
* Set a JSON-format `Custom properties` (optional).

## Workflow Level Customizations

When triggering a workflow, it is possible to pass the tenant information (id or object, in case of an object, novu will upsert the tenant if it’s not existing) like so:

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
      import { Novu } from '@novu/node';

      const novu = new Novu("<NOVU_API_KEY>");

      await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
        {
          to: {
            subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          },
          payload: {
            name: "Hello World",
          },
          actor: "actorId"
          tenant: "tenantIdentifier"
        }
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
      use Novu\SDK\Novu;

      $novu = new Novu('<NOVU_API_KEY_HERE>');

      $novu->triggerEvent([
        'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
        'payload' => [
          'name' => 'Hello'
        ],
        'to' => [
            'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
        ],
        'actor': "actorId"
        'tenant': "tenantIdentifier"
      ]);
    ```
  </Tab>
</Tabs>

The tenant information can now be used inside the workflow template in the following way:

```
{{ tenant.data.customProp }}
```

## Workflow Settings Override

Workflow settings can now be updated on the workflow per tenant. This enables each tenant to have unique preferences that doesn't affect others within the same workflow.

The `active` and `channel` preferences fields of a workflow can be updated to be tenant-specific the [workflow-overrides API endpoint](/api-reference/workflow-overrides/create-workflow-overrides).

<Warning>This feature is only available from v0.22.0.</Warning>

## Integration Level Customizations

When creating an integration, you can create a condition where you can specify a delivery provider for a channel when a particular tenant id is matched.

The delivery provider specified will only be used if the trigger is executed with the tenant id.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Tenant-specific Notification Content

When creating a step, variants could be created for each step including digest and delay. For each variant, conditions set can be applied on when this variant could be used.

Using so different workflow configurations (for example digest duration) could be configured on the individual workflow for a given tenant.

For example, if you want a specific notification content to be sent to a tenant named "JohnDoe", and another to be sent to others. You can do the following:

* Create an email step in your workflow
* In the email step workflow, click on the "Add variant" icon at the top right to add a new variant.

<Frame>
  <img />
</Frame>

* It opens up the condition page. Set the tenant identifier to equal "JohnDoe".

<Frame>
  <img />
</Frame>

* Apply Conditions as shown above.
* Check the email step in the workflow, you'll see the **root variant** and **v1 variant**.

<Frame>
  <img />
</Frame>

Once a trigger runs, the Novu engine checks to see if there's a `tenant` identifier specified in the trigger code.

An example of the trigger code:

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
      import { Novu } from '@novu/node';

      const novu = new Novu("<NOVU_API_KEY>");

      await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
        {
          to: {
            subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          },
          tenant: "JohnDoe"
        }
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
      use Novu\SDK\Novu;

      $novu = new Novu('<NOVU_API_KEY_HERE>');

      $novu->triggerEvent([
        'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
        'to' => [
            'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
        ],
        'tenant': "JohnDoe"
      ]);
    ```
  </Tab>
</Tabs>

* If it exists, a condition check is done to see if there's a variant that matches the tenant identifier.
* If there's a match, the specific variant template will be fired.
* If there's no match, the root variant template will be fired.

It is also possible to use handlebars to have minor tenant adjustments in a single step:

```
<img src="{{tenant.data.logo}}" />
```

<Warning> For self-hosted users, this is only available from version 0.22.0. </Warning>


# Delay Action
Source: https://v0.x-docs.novu.co/workflows/delay-action

More on how Delay Action Node works

The delay action awaits a specified amount of time before moving on to trigger the following steps of the workflow.

### Delay Action Node

After adding a delay node in the workflow editor, the immediate next step will only be triggered after the specified period of time has elapsed.

# Configurations

## Regular Delay

Regular Delay will determine how long it will take before triggering the next step.

## Time Interval

You can specify the amount and time unit that best suits your needs.

Should you wish to, you could override the default delay time interval you set in the creation of the delay node.

```tsx theme={null}
novu.trigger('template-name', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>'
  },
  payload: {
    name: 'Hello',
  },
  overrides: {
    delay: {
      unit: 'days',
      amount: 2,
    },
  },
});
```

## Scheduled Delay

Scheduled Delay allows delaying up to a future date before continuation of steps execution. All steps after delay node will be triggered only after said date.

### Payload Path[](https://docs.novu.co/platform/delay#payload-path)

Payload path will determine the path in payload for the scheduled date.

That path must be included in your payload on trigger execution and must be a date in strict ISO format.

For example:

<img />

```tsx theme={null}
novu.trigger('workflow-name', {
  to: {
    subscriberId: '<SUBSCRIBER_ID>'
  },
  payload: {
    sendAt: '2022-09-21T10:48:44.388Z',
  },
});
```

<Note>
  Date must be in ISO date format of YYYY-MM-DDThh:mm:ss.SSSZ
</Note>


# Digest Engine
Source: https://v0.x-docs.novu.co/workflows/digest

Deep dive into Digest functionality

The digest engine collects multiple trigger events, aggregates them into a single message and delivers it to the subscriber.

This becomes useful when a user needs to be notified on a large amount of triggers and you want to avoid sending too many notifications. Novu will automatically batch the incoming trigger events based on the `subscriberId` and an **optional** `digestKey` that can be added to control the digestion of the events.

### Digest Node

After adding a digest node in the workflow editor, each node that will be below the digest node will be only triggered once in the specified digest interval. You can decide to send messages before adding a digest node and they will be triggered in real-time.

<Frame>
  <img />
</Frame>

In the image above, there are two nodes (`Email` and `SMS`) after the digest node and one node (`In-App`) before the digest node in the workflow.

For this workflow, if we trigger 10 events within the digest interval, the `In-App` step will be executed 10 times, and `Email` and `SMS` will be executed only 1 time with digested events data.

## Digest Configuration

### 1. Digest Key

If specified, the digest engine will group the events based on the `digestKey` and `subscriberId`, otherwise the digest engine will group the events based only on the subscriberId.

The digest key might come useful when you want a particular subscriber to get events grouped on a custom field. For example when an actor likes the user's post, you might want to digest based on the `post_id` key.

<Frame>
  <img />
</Frame>

### 2. Time Interval

The time interval determines how long the digest engine will wait before sending the message once created. You can specify the amount and the unit that best suits your needs.

Here, in the image below, `5` is the interval amount, and `mins` is the interval unit. Interval units can be `sec(s)`, `min(s)`, `hour(s)`, or `day(s)`.

<Frame>
  <img />
</Frame>

## Digest Strategy Types

The strategy which Novu should use to handle the digest step. More details on available strategies below.

Novu allows you to define different digest strategies depending on the actual use-case you are trying to achieve. At this point we allow you to select from 2 strategies:

* Regular Strategy
* Back-off Strategy

Let's explore them in detail:

#### Regular Strategy

In regular strategy, a digest will always be created for the specified window time. Which means that from the first event trigger, if no active digest exists for this subscriber, one will be created and the user will receive the message only when the digest window time is reached.

#### Back-off Strategy

In the back-off strategy, before creating a digest, Novu will check if a message was sent to the user in the back-off period. If a message was sent, a digest will be created. Otherwise, a message will be sent directly to the user and the digest creation will be skipped.

Backoff digest has two intervals, `digest interval` and `backoff interval`. Here, in the image below, the `digest interval` is `20 minutes`, and the `backoff interval` is `15 minutes`. In the case of a backoff digest, first, it checks if any event is triggered within the past backoff interval, only then a digest is created for the digest interval. If not, the event is considered non-digest and workflow execution continues to the next step.

<Frame>
  <img />
</Frame>

**Example:**

Let's set the digest interval as 20 minutes and the backoff time as 15 minutes.

If we trigger the first event. Since it is the first event and there was no event triggered in the past 15 minutes (backoff interval), this event will be executed as it is (without digest).

Now, if we trigger a second within 15 minutes, then a new digest will be created with this second event. From now onwards till 20 minutes (digest interval), all triggers will be digested in this digest, and after 20 minutes, the workflow will carry forward to the next step with digested events.

## Scheduled Digest

**Minutes:**

It digests events for every specified minutes. For example, as per the image below, events will be digested for 20 minutes and after 20 minutes, workflow will carry forward to the next step. It will be repeated after every 20 minutes.

<Frame>
  <img />
</Frame>

**Hour:**

It digests events for given hours. After given hours, a new digest is created.

<Frame>
  <img />
</Frame>

**Daily:**

It digests events for specified days till given time. After those days and time, a new digest is created and events are digested in this new digest.

<Frame>
  <img />
</Frame>

**Weekly:**

It digests events for specified weekdays. Only at the specified time, the workflow continues to the next step after the digest step. A new digest is created and events are digested in this new digest till these weeks and time.

<Frame>
  <img />
</Frame>

**Monthly:**

<Frame>
  <img />
</Frame>

## Writing digest templates

In many cases, you will need to access all the digested events payload in order to show the user all or parts of the events included in this digest. For example: **"John and 5 others liked your photo."**

As part of the digested template, you will have access to a few properties:

| Property           | Description                                                                                                                                       |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| `step.events`      | An array of all the events aggregated under this digest. This will be the "payload" object passed to each trigger.event sent in the digest period |
| `step.total_count` | The number of total events in this digest                                                                                                         |
| `step.digest`      | A boolean flag to indicate if we are in a digest mode right now                                                                                   |

Let's look at a handlebars syntax example for the following triggers:

```tsx theme={null}
novu.trigger('workflow-name', {
  to: '123',
  payload: {
    name: 'Hello',
  },
});

novu.trigger('workflow-name', {
  to: '123',
  payload: {
    name: 'World',
  },
});
```

After these two triggers, digest variables are as follows:

| Property           | Description                                     |
| ------------------ | ----------------------------------------------- |
| `step.events`      | `[ { "name" : "Hello" }, { "name": "World" } ]` |
| `step.total_count` | `2`                                             |
| `step.digest`      | `true`                                          |

Using the following template:

```HTML theme={null}
Total events in digest:
{{step.total_count}}

{{#if step.digest}}
  {{#each step.events}}
    {{name}}
  {{/each}}
{{else}}
  Not a digested template
{{/if}}
```

It will render as:

`Total events in digest: 2 This is Hello payload event This is World payload event`

<Note> Note that if only one matching trigger activates a regular digest during its period, that single item will still come through as a digest with `step.total_count` as 1. </Note>

### Using subscriber variables

Subscriber variables like `{{subscriber.firstName}}` , `{{subscriber.email}}` etc are system reserved variables. These variables can be used in the same form if used outside of `step.events` iteration. If you want to use subscriber variables inside `step.events` iteration, you can use `{{../subscriber.firstName}}` , `{{../subscriber.email}}`. Reason of this change inside `step.events` iteration is the context change. Subscriber variables are available in the parent context of `step.events` iteration.

```HTML theme={null}
Total events in digest:
{{step.total_count}}
Hey, {{subscriber.firstName}} your id is {{subscriber.subscriberId}}
{{#if step.digest}}
  {{#each step.events}}
    {{name}}
    <br/>
    {{../subscriber.firstName}} your email is {{../subscriber.email}}
  {{/each}}
{{else}}
  Not a digested template
{{/if}}
```

## Event cancellation from Digest

Any event can be cancelled from the Digest via the [event cancellation API](/api-reference/events/cancel-triggered-event) using transactionId of triggered event. For example, if there are 5 events in digest, a user should be able to cancel the **2nd**, **3rd**, or **4th** event before digest time completion.

The cancelled event will not be included in the final digest events array.

## Digest Guides

<CardGroup>
  <Card title="Add Digest to Email Notifications" icon="envelope" href="/guides/add-digest-to-email-notifications">
    Learn how to add digest functionality to email notifications.
  </Card>

  <Card title="Add Digest to In-App Notifications" icon="bell" href="/guides/add-digest-to-inapp-notifications">
    Learn how to add digest functionality to a In-App feed within React app.
  </Card>
</CardGroup>

## Frequently Asked Questions

<Note>All digest times are in UTC time</Note>

<AccordionGroup>
  <Accordion title="If scheduled digest is set for 9:00 AM daily then will the digest be sent at 9:00 AM every day without any event triggered?">
    If scheduled digest is sent for 9:00 daily, then novu will collect all events triggered between 9:00 AM today till 9:00 AM tomorrow and send the digest at 9:00 AM tomorrow. This process is repeated daily. If there is no any event triggered between 9:00 AM today and 9:00 AM tomorrow, then no digest will be sent.
  </Accordion>

  <Accordion title="What is the difference between Regular and Schedules Digest set to 1 Hour?">
    Both digests are same in this case.
  </Accordion>
</AccordionGroup>


# Messages
Source: https://v0.x-docs.novu.co/workflows/messages

Learn about messages in Novu

Each [workflow](/workflows/notification-workflows) has one or more than one step. Each step is either a `channel` (in\_app, email, push, chat) or an `action` (digest, delay).

Within the workflow, every channel has a separate template. Email channel step content can be different than `in_app` channel step content. When a workflow is triggered, Novu generates separate messages for every channel step and sends that message to the recipient.

A triggered event (`notification`) is a collection of step information, its message, and job execution details.

## List messages

Messages can be listed using these SDK methods. These methods support pagination using page and limit field and filters using channel, subscriberId and transactionId field.

<Info>Novu will throw 404 error if requested subscriberId is not a valid subscriberId of any existing subscriber.</Info>

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu, ChannelTypeEnum } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    await novu.messages.list({
      page: 0,
      limit: 30,
      channel: ChannelTypeEnum.IN_APP,
      subscriberId: '<SUBSCRIBER_ID>'
      transactionIds: ['transactionId1', 'transactionId2'],
    });
    ```
  </Tab>
</Tabs>

### List messages example response

```javascript theme={null}
{
  "page": 0,
  "totalCount": 987,
  "hasMore": true,
  "pageSize": 30,
  "data": [
    ....
    {
      "cta": {
          "action": {
              "buttons": []
          },
          "type": "redirect",
          "data": {
              "url": ""
          }
      },
      "_id": "messageId",
      "_templateId": "workflowId",
      "_environmentId": "environmentId",
      "_messageTemplateId": "messageTemplateId",
      "_notificationId": "notificationId",
      "_organizationId": "organisationId",
      "_subscriberId": "_subscriberId",
      "_jobId": "jobId",
      "templateIdentifier": "workflowIdentifier",
      "_feedId": "feedId",
      "channel": "in_app",
      "content": "Message Content",
      "deviceTokens": [],
      "seen": false,
      "read": false,
      "status": "sent",
      "transactionId": "d5218a6c-4b08-4617-b176-2d2271f34e42",
      "payload": {
          "key": "value"
          "__source": "test-workflow"
      },
      "expireAt": "2024-06-17T08:18:29.871Z",
      "deleted": false,
      "createdAt": "2023-06-17T08:18:29.871Z",
      "updatedAt": "2023-06-17T08:24:34.888Z",
      "__v": 0,
      "subscriber": {
          "_id": "_subscriberId",
          "subscriberId": "subscriberId",
          "id": "_subscriberId"
      },
      "actorSubscriber": 'actorSubscriberId',
      "id": "messageId"
    }
    ....
  ]
}
```

## Delete a message

A single message can be deleted by messageId using these SDK methods. messageId should be a valid objectId parsed as a string.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu('<NOVU_API_KEY>');

    const messageId = '64452b58ec0dbb9e41b4dccf';

    await novu.messages.deleteById(messageId);
    ```
  </Tab>
</Tabs>

### Delete a message example response

```javascript theme={null}
{
  data: {
    acknowledged: true,
    status: 'deleted'
  }
};
```

## API Reference Links

* [List Messages API](/api-reference/messages/get-messages/)
* [Delete a Message API](/api-reference/messages/delete-message/)


# Workflows
Source: https://v0.x-docs.novu.co/workflows/notification-workflows

Here you learn all about workflows

A workflow holds the entire flow of steps (nodes) that are sent to the subscriber. This is where all the different channels are tied together under a single entity.

<Note>
  Notification template has been renamed to workflow. Previously, workflow has been referred to as notification template.
</Note>

## Structure

A workflow acts as the blueprint for the notifications that will be sent. The workflow encapsulates the entire flow and rules of messages that are being sent. This is where all the different channels, filters, rules and actions are tied together under a single entity.

<img />

## Workflow Components

<Steps>
  <Step title="Name and Identifier">
    Every workflow will have a name and an identifier that are used to uniquely identify each workflow.
  </Step>

  <Step title="Trigger">
    The "Trigger" refers to an event or action that initiates the workflow. It signifies a call to the Novu API with a specified workflow ID, along with the necessary payload data that the workflow content will utilize.
  </Step>

  <Step title="Channels">
    In Novu, a channel refers to a preconfigured provider through which notifications are dispatched to recipients. In most instances within Novu, these channels utilize the credentials you provide to ensure the delivery of notifications on your behalf. The combination of these credentials and accompanying settings constitutes a configured channel.

    Within the Novu framework, channels are categorized into various types, each of which is linked with at least one corresponding provider that can be tailored as needed:

    * **Email** (examples include Sendgrid, Postmark)
    * **In-App** (such as feeds, toasts, banners)
    * **Push** (such as APNS, FCM)
    * **SMS** (examples include Twilio, Telnyx)
    * **Chat** (such as Slack, Microsoft Teams, and Discord)
    * **Webhook** (used to send webhooks to custom channels or enable your customers to configure webhooks within your product)
  </Step>
</Steps>

## Execution of Workflow Steps

Once a workflow is initiated by its trigger, the steps (and channels) within the workflow are executed in a specific sequence. This sequential execution ensures that each step is completed before the next one begins, maintaining a controlled and orderly flow of the notification process. Here's what you need to know about this process:

* **Sequential Execution:** Each channel in the workflow is activated one after the other, in the order they are listed within the workflow. This method ensures that each step is given the necessary attention and that dependencies or prerequisites of later steps are adequately met.

* **Order of Channels:** The order in which channels are listed in the workflow is crucial, as it dictates the sequence of their execution. You should carefully consider the order when setting up your workflows to align with your notification strategy.

Sequential execution provides a predictable and reliable workflow process, ensuring that messages are sent out in an organized manner and that each step's output potentially influences the subsequent ones.

<br />

<Warning>Once a workflow is triggered, it can not be changed.
<br /> <br /> Workflow can be canceled only using  [DELETE /events/cancel api](/api-reference/workflows/delete-workflow)</Warning>

<Note>Subscriber is not allowed to manage subscriber preference for [critical workflow](/subscribers/preferences#exclude-workflows-from-preferences-critical-workflow)</Note>

## Workflow Groups

Workflow groups are used to categorize workflows based on their purpose or function. This grouping allows you to organize your workflows in a way that makes sense to you and your team. For example, you may want to group all your onboarding workflows or group all your transactional workflows together. You can create as many groups as you need and assign workflows to them as you see fit.

<Info>Currently workflow group is just for reference purposes and cannot be used for bulk action related to all workflows belonging to a workflow group.</Info>

### Working with workflow groups

**To create a workflow group, follow these steps:**

1. Navigate to the **Workflows** page in the Novu interface.
2. Select any workflow from the list.
3. Click on the **cog** icon on the top right side to open the workflow settings.
4. Stay on the *General* settings tab.
5. Click on the **Workflow Group** dropdown and select the group you want to assign to the workflow.
6. To create a new group start writing some text and a **Create New** option will appear. Click on it to create a new group and select this group for this workflow.
7. Click on the update button on the top right side to save the changes for the entire workflow.

<Frame>
  <img />
</Frame>

To edit a workflow group name, follow these steps:

1. Navigate to the **Settings** page in the Novu interface.
2. Copy the **API Key** from settings (Each environment has a different API Key).
3. Navigate to [API Reference](https://docs.novu.co/api-reference/workflow-groups/get-workflow-groups) page to fetch all workflow groups in Novu documentation.
4. Use the previously copied **API Key** as the **Authorization** header. Make sure it is in the correct format `ApiKey <API_KEY>`
5. Click on the send button to fetch all the workflow groups.
6. In the response field copy the **\_id** field of the workfow group that you want to edit.
7. Use the copied **\_id** as the **path parameter** in the request URL of [workflow update](https://docs.novu.co/api-reference/workflow-groups/update-workflow-group) API using the same **API Key** as the **Authorization** header. Write the new name for the group in the **body** field.
8. Click on the send button to update the workflow group name.

<Info>To delete the workflow group use [delete workflow group api](https://docs.novu.co/api-reference/workflow-groups/delete-workflow-group) with the same steps as updating the workflow group name. However, it is not recommended to delete the workflow group if at least one workflow is attached to this workflow group or there exists a change promotion item on the changes page</Info>

## Searching Workflows

Workflows can be searched by their name or trigger identifier. This feature makes it easy to find the desired workflow and quickly access its details.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## FAQs

<AccordionGroup>
  <Accordion title="Workflow Promotion Error: Notification Group Id Not Found">
    To address the error "Notification Group Id not found" when promoting the workflow from dev to prod, it's essential to check the allocation of a notification group to the workflow. Here is an outlined process to validate:

    <Steps>
      <Step title="Go to the workflow settings in Novu's interface." />

      <Step title="Remain within the general settings tab." />

      <Step title="Check the right-hand side for the notification group dropdown." />

      <Step title="Verify if any group is selected. The group's association will be demonstrated here." />
    </Steps>

    <Tip>New notification group can also be created in the drop-down</Tip>

    If a notification group is not associated, this is likely the cause of the issue. Ensure that the relevant Notification Group Id is assigned in the settings. To do so, you would need to choose one from the drop-down list in the workflow settings .

    <Frame>
      <img />
    </Frame>

    Remember, deleting a workflow is not recommended because it can lead to unexpected behavior like this. Instead, updating the workflow group associated with the specific workflow is the right process to address the issue.
  </Accordion>

  <Accordion title="How to disable a workflow for a single subscriber?">
    When all channels are turned off for that subscriber then subscriber will not receive any messages from any channel step, effectively disabling the workflow for that subscriber.

    2. If you want to make a workflow inactive or active, you can do so through the workflow settings. However, it's important to note that this action will affect **all** subscribers.

    3. To disable a workflow for only one subscriber, you can achieve this by having the subscriber disable all channels for that specific workflow through their subscriber preferences. This action will solely impact that particular subscriber.
  </Accordion>

  <Accordion title="What is the difference between workflowId and trigger identifier?">
    `workflowId` is a MongoDB-generated identifier within the Novu system, serving as a unique identifier for workflows. It cannot be modified or altered once generated. This `workflowId` is utilized in several APIs, including the [GET Workflow API](https://docs.novu.co/api-reference/workflows/get-workflow).

    <img />

    A `trigger identifier` is a distinctive label utilized to activate a workflow, typically represented in a slugified format. Novu generates this identifier automatically based on the workflow's name, and it can be modified at a later time if needed. Currently, our system supports only a single trigger identifier per workflow. However, as part of our future plans, we intend to enable the use of multiple trigger identifiers for a single workflow, each capable of initiating the workflow from different sources.

    <img />

    Hence, while `workflowId` refers to the umbrella structure that holds the entire flow of messages, the `trigger identifier` is the specific event that starts this sequence.
  </Accordion>

  <Accordion title="How does Novu prevent duplicate notifications sent to subscribers?">
    The `transactionId` within Novu is a unique identifier that is used to ensure the idempotent nature of notification delivery.

    When you trigger an event to send a notification, you have the option to provide a `transactionId`. If you do not provide one, Novu will generate a UUID for you.

    **This identifier is particularly useful for preventing the same notification from being sent multiple times in case the trigger event is inadvertently called more than once.**

    By leveraging the `transactionId`, you can make idempotent requests, which means if the same `transactionId` is used in another request, Novu's API will recognize it and will not send the same notification again.

    <Note>
      This upholds the principle of idempotency, ensuring that the effect of the operation is the same, no matter how many times the request is repeated with the same `transactionId`.
    </Note>
  </Accordion>
</AccordionGroup>


# Step Conditions
Source: https://v0.x-docs.novu.co/workflows/step-filters

Learn how to customize your notifications flow in Novu.

Workflow step conditions allow you to customize the flow of notifications in your workflow by specifying criteria for which notifications should be delivered.

You can use these conditions to ensure that only relevant notifications are sent to your subscribers, improving the efficiency and effectiveness of your communication.

<Warning>**Step Conditions** used to be called **Step Filters**.</Warning>

## On Condition

* On `payload`: You can specify a list of keywords or values that the `payload` field must match in order for the notification to be delivered. This is useful if you only want to receive notifications that contain certain information.
* On `subscriber`: You can filter which subscriber should receive notifications based on subscriber information. This means that you can send notifications to specific individuals or groups rather than all subscribers. It checks on subscriber attributes. Read more about [subscriber attributes](https://docs.novu.co/subscribers/subscribers#subscriber-attributes).
* On `webhook`: You can use this feature to provide information about subscribers from specified webhook response and use that information to filter the notification flow. For example, if your webhook returns a field indicating whether a subscriber is currently online, you can use this field to send notifications only to online subscribers.
* On `online right now`: You can filter notifications on the basis of the current online status of the subscriber. For example, You can choose to send a notification if the subscriber is currently online or offline.
* On `online in the last "X" time period`: You can use this to filter notifications for a subscriber if the subscriber was online in the last `X` minutes/hours/days.

### Steps to set Conditions

1. Create a step in your workflow. This step will be the location where you will apply your filter.
2. Add a condition to the step. This will allow you to specify the criteria that must be met for the notification to be delivered.

<Frame>
  <img />
</Frame>

3. If you want to add multiple conditions, you will need to choose a logical condition between `AND` and `OR` . This will determine how the conditions are applied to the notification. For example, if you choose `AND`, the notification will only be delivered if all of the conditions are met. If you choose `OR`, the notification will be delivered if any of the conditions are met.
4. Add a rule to the condition. This will specify the criteria that must be met for the notification to be delivered. You can use the `payload`, `subscriber`, or `webhook` field as the basis for your rule. For example, you might specify that the `payload` field must contain a certain keyword or that the `subscriber` must be in a specific group.

## Condition rule

A condition rule is composed of the following fields:

* **On** : This specifies which field the rule should be applied to, such as `Payload`, `Subscriber`, or `Webhook` response.
* **Key** : This specifies the object key that the rule should be applied to. For example, if the `On` field is `Subscriber`, the `Key` field might be `name`, `email` etc.
* **Operator** : This specifies the comparison operator to use when evaluating the rule. Options include **Equal**, **Not equal** , **Larger** , **Smaller** , **Larger or equal**, **Smaller or equal** , **Contains**, **Not contains** and **Is Defined**.
* **Value** : This specifies the `value` to compare to the object key value using the selected `operator`. The value field also accepts variables.

<Frame>
  <img />
</Frame>

**Example of a condition rule**:

In this condition, the notification will only be delivered if the webhook response includes a field called `isOnline` that is set to `true`.

<Frame>
  <img />
</Frame>

## Conditions with Webhook

To filter notifications based on a webhook response, you will need to create a webhook that accepts POST requests and returns a one-level object. The webhook should be set up to receive object the following parameters:

* **subscriber** - This is an object containing information about the subscriber that the notification is being sent to.
* **payload** - This is an object containing the payload of the trigger that initiated the notification.
* **identifier** - workflow identifier is a unique identifier for the notification template being used.
* **providerId** - provider identifier is a unique identifier for the communication provider you used on this notification.
* **channel** - The channel identifier specifies the type of notification channel that was used to send the notification.

### Securing your webhooks

To secure your webhooks, Novu uses the `nv-hmac-256` header as a security measure.

This header contains an HMAC hash that is calculated based on your `API Key` 
and `Environment Id`, ensuring that the request is coming from Novu.
This helps in protection against unauthorized access and tampering with your webhooks.

To verify the authenticity of the request, you can use the following code:

```jsx theme={null}
import { createHmac } from 'crypto';

const hmacHash = createHmac('sha256', 'NOVU_API_KEY').update('ENVIRONMENT_ID').digest('hex');

if (hmacHash === hmac) {
  // The request is authentic
} else {
  // The request is not authentic
}

```

> **ENVIRONMENT\_ID** can be accessed in the webhook subscriber parameter in the request body. **NOVU\_API\_KEY** can be found in the settings section of the Novu client.

The webhook should return a one-level object containing any information that you want to use to filter the notification flow. For example, you might include a field called `isOnline` having value `true` or `false` that specifies whether the subscriber is currently online or not.

## Subscriber online conditions

This allows you to apply a condition on a workflow step based on the `subscriber's` online status. The condition can be applied to determine if the subscriber is currently online or if the subscriber was online in the **X** time-period.

**Example** : To send an email notification to all subscribers who were active within the last 30 minutes, follow these steps:

* On the Workflow editor page, add an `Email` step after trigger in workflow.
* Click on the email step to edit its content template.
* Click on the  `Add conditions` button from the upper right position.

<Frame>
  <img />
</Frame>

* Click `Add condition` to add a rule.
* Select `Last time was online` and choose `minutes` as the time period.
* Enter `30` in the input field.

<Frame>
  <img />
</Frame>

By applying this condition, the notification will only be delivered to subscribers that were last active in the past 30 minutes, ensuring that the message is reaching engaged and active recipients.

### Online condition mechanism

Novu uses a websocket connection within the `notification-center` package to track the online status of subscribers. The `isOnline` and `lastOnlineAt` fields of the subscriber's entity are updated accordingly.

When a subscriber comes online, an active websocket connection is established with the server. Novu then updates the `isOnline` field of the subscriber's entity to `isOnline: true`. When the subscriber disconnects, Novu updates `isOnline: false` and `lastOnlineAt: current_timestamp`.

The online condition feature can be used to determine if a subscriber is online right now or if the subscriber was online within a specific time period.

* To determine if a subscriber is online right now, Novu checks the value of the `isOnline` field. If `isOnline` is `true`, the subscriber is online, otherwise when the `isOnline` is `false` the subscriber is considered offline.
* To determine if a subscriber was online within a specific time period, Novu compares both the `isOnline` and `lastOnlineAt` fields. If `isOnline` is `true`, the subscriber is still online and the condition is applied. If `isOnline` is `false`, the difference between the `current timestamp` and the `timestamp` value of `lastOnlineAt` is calculated. If this difference is within the specified time period, the subscriber was online within that time period and the condition is applied. Otherwise, the condition is not applied.

For example, to determine if a subscriber has been online in the last 5 minutes, Novu checks if the subscriber is currently online or if the `lastOnlineAt` timestamp value is less than or equal to 5 minutes ago. If either of these conditions are met, the condition is applied.

## Subscriber Seen / Read Conditions

This condition gives the flexibility of executing successive step notifications based on the status of previous step notification. It currently works for in-app and email step notifications.

**Typical Use Case**:

You have a set of customers to whom you need to send a 2-step email. However, they should only get the second email if they have read/seen the first email.

With the seen/read condition, you can do the following in a workflow:

* Set the first email step.
* Set a delay.
* Set the second email step.
* Create a condition on the second email step that indicates if the previous step needs to be seen/read before it should be executed.

<Frame>
  <img />
</Frame>

<Note> For this condition to work with emails, the webhook url needs to be set up for the active `email` provider you're using on Novu. It's very essential for the condition to work. No extra set up is needed for `in-app` notifications. </Note>

## Is Defined Condition

Is Defined condition checks whether specified `key` exists or not. It is different from `Equal` and `Not equal` condition. `Equal` and `Not equal` condition checks whether key value is equal to specified value or not, but `Is Defined` condition just checks whether key is present or not.

<Frame>
  <img />
</Frame>

<Note> This condition can be used with subscriber, payload and webhook. It can be applied on all channels. </Note>

## Monitoring the condition's status inside Activity Feed

To check if the notification sent was conditioned or not, visit the `Activity Feed` page.

* Select the notification you're interested in checking the filter status for.
* A new popup `Execution Details` will open up.

<img />

* Click on the notification step row to open up the details for the corresponding step.
* On this screen, you can monitor the notification status along with filter details if any.

<img />

<Info>Digest variables (step.digest, step.events, step.total\_count) are not supported in step conditions.</Info>


# Template Store
Source: https://v0.x-docs.novu.co/workflows/template-store

Display inline code and code blocks

The Novu dashboard features an integrated template store for workflows, offering a range of ready-to-use options.

From basic alerts to intricate sequences, you can select a template, customize it, and swiftly trigger notifications tailored to your needs.
This streamlined process cuts down development time and empowers you to communicate effectively with minimal effort.

<img />


# Variants
Source: https://v0.x-docs.novu.co/workflows/variants

Learn how to create and use multiple variants for workflow steps in Novu.

Variants is a workflow component that empowers users to create multiple versions of a given workflow step.

You can use variants to ensure that only specific versions of your workflow step (e.g Email) are sent to subscribers. These variants are linked to specific conditions. No variant can exist without a condition.

Variants are an integral component of our [multi-tenancy feature](/tenants/introduction#tenant-specific-notification-content).

## Steps to create Variants

In this case, we'll use a workflow Email step. Let's create multiple variants for this step.

1. Create an email step in your workflow.

<Frame>
  <img />
</Frame>

2. Add a variant to the step as shown below.

<Frame>
  <img />
</Frame>

3. A variant must have conditions set. Add a condition or multiple conditions.

<Frame>
  <img />
</Frame>

In this case, we added a condition (as shown below) to check if the tenant identifier passed at the point of trigger is equal to `edenlife`. This is now a **multi-tenant variant**!

Apply conditions to set it successfully.

<Frame>
  <img />
</Frame>

The variant has been created. Click on the **Update** button.

<Frame>
  <img />
</Frame>

4. Head over to the email step again. You will see two variants: the **root variant** & **v1 variant**. The **v1 variant** is the one where you set the tenant condition while the **root variant** is the default version of the email step without a condition.

<Frame>
  <img />
</Frame>

5. You can add different content to the two variants.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

During the notification sending phase, Novu's logic will determine the appropriate variant based on the contextual information that was passed with the trigger event and the conditions applied to the variants.

In this case, if a tenant identifier with the value of `edenlife` was passed with the trigger event, then Novu will select the v1 variant and send to subscribers.

On the other hand, if the tenant identifier has a different value or was not passed with the trigger event, then Novu will select the root variant and send to subscribers.

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
      import { Novu } from '@novu/node';

      const novu = new Novu("<NOVU_API_KEY>");

      await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
        {
          to: {
            subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          },
          payload: {
            name: "Hello World",
          },
          tenant: "edenlife"
        }
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
      use Novu\SDK\Novu;

      $novu = new Novu('<NOVU_API_KEY_HERE>');

      $novu->triggerEvent([
        'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
        'payload' => [
          'name' => 'Hello'
        ],
        'to' => [
            'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
        ],
        'tenant': "edenlife"
      ]);
    ```
  </Tab>
</Tabs>

## Variant Conditions

There are so many use cases for variants. It's not limited to [multi-tenancy](/tenants/introduction#tenant-specific-notification-content).

You can set conditions based on the following data:

* Subscriber
* Payload
* Webhook
* Is online
* Last time was online

### Sample Use Cases

1. If you're looking to send a different type of email based on whether a subscriber is online, then variants are the right choice.

2. If you want to send different types of email to subscribers based on the specific type of payload or subscriber data passed with the trigger event, variants are a good choice!


# Data Migrations
Source: https://v0.x-docs.novu.co/additional-resources/data-migrations

Learn how to update your database data through migrations.

On occasion, Novu may introduce features that require changes to the database schema or data.
This usually happens when a feature has a hard dependency on some data being available on a database entity.
You can use migrations to make these changes to your database.

## Running Migrations

To run data migrations, enter the following sequence of commands in your terminal from the [`novuhq/novu`](https://github.com/novuhq/novu) repository root:

```bash theme={null}
npm run setup:project
cd apps/api
npm run migration -- ./migrations/<MIGRATION_PATH>.ts
# e.g. npm run migration -- ./migrations/add-user-contact/add-user-phone.ts
```

Some features may have multiple migrations, in which case you will need to run each migration in the order shown below.

## Migrations History

Below you will find a list of migrations introduced in previous versions of Novu, alongside the migration path to use in the script above.

| Version                                                      | Feature                 | Migration Path(s)                                                                                                                          |
| ------------------------------------------------------------ | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| [v0.23](https://github.com/novuhq/novu/releases/tag/v0.23.0) | API keys encryption     | `./encrypt-api-keys/encrypt-api-keys-migration.ts`                                                                                         |
| [v0.18](https://github.com/novuhq/novu/releases/tag/v0.18.0) | Multi-Provider          | `./integration-scheme-update/add-primary-priority-migration.ts`<br />`./integration-scheme-update/add-integration-identifier-migration.ts` |
|                                                              | Integration Store       | `./novu-integrations/novu-integrations.migration.ts`                                                                                       |
| [v0.16](https://github.com/novuhq/novu/releases/tag/v0.16.0) | In-App Integration      | `./in-app-integration/in-app-integration.migration.ts`                                                                                     |
|                                                              | Secure Flag Fix         | `./secure-to-boolean/secure-to-boolean-migration.ts`                                                                                       |
| [v0.15](https://github.com/novuhq/novu/releases/tag/v0.15.0) | Database TTL            | `./expire-at/expire-at.migration.ts`                                                                                                       |
| [v0.12](https://github.com/novuhq/novu/releases/tag/v0.12.0) | Organization Invite Fix | `./normalize-users-email/normalize-users-email.migration.ts`                                                                               |
| [v0.9](https://github.com/novuhq/novu/releases/tag/v0.9.0)   | Seen/Read Support       | `./seen-read-support/seen-read-support.migration.ts`                                                                                       |
| [v0.8](https://github.com/novuhq/novu/releases/tag/v0.8.0)   | Secure Credentials      | `./fcm-credentials/fcm-credentials-migration.ts`<br />`./encrypt-credentials/encrypt-credentials-migration.ts`                             |
| [v0.4](https://github.com/novuhq/novu/releases/tag/v0.4.0)   | Change Promotion        | `./changes-migration.ts`                                                                                                                   |


# Glossary
Source: https://v0.x-docs.novu.co/additional-resources/glossary

Definitions

## Introduction

In this section, you’ll find a list of key terms, their definitions and various concepts associated with Novu. Familiarising yourself with these will help you understand and use Novu better. They will help you navigate our docs more effectively and utilise Novu to its maximum potential.

If you have any questions or need further clarification on any of the terms listed above, please feel free to reach out to our support team or join our community!

## List of key terms and definitions

## Notification

A brief message or alert that informs users about events, updates, or some other information

## Channels

Novu lets you send notifications across different communication mediums, including emails, in-app messages, push notifications, SMS, and chat. Each of these five communication mediums is referred to as a notification ‘channel’.

<Frame>
  <img />
</Frame>

## Providers

Providers are responsible for handling message delivery across various channels. Novu currently supports multiple notification channels, each with its own set of providers.

* Chat: This channel offers these providers:
  * Discord
  * MS Teams
  * Slack
  * Zulip
* Email: The Email channel features these providers:
  * Sendgrid
  * Amazon SES
  * Sendinblue
  * Resend
  * SparkPost
  * Postmark
  * Mailjet
  * Mailtrap
  * Plunk
  * Braze
  * Mailersend
  * Outlook 365 (based on a custom SMTP server)
  * Mailgun
  * Mandrill
  * Netcore
  * Infobip, and
  * Custom SMTP
* SMS: The SMS channel features these providers:
  * Twilio SMS
  * SMS77
  * Africa’s Talking
  * Infobip
  * Nexmo
  * Plivo
  * Sendchamp
  * AWS SNS
  * Telnyx
  * Termii
  * Firetext
  * Gupshup
  * Clickatell
  * Azure SMS
  * BulkSMS
  * SimpleTexting
  * MessageBird
* Push Notification Providers: This channel includes these providers:
  * Firebase Cloud Messaging (FCM)
  * Expo Push
  * Apple Push Notification Service (APNS)
  * One Signal
  * Pushpad
  * Pusher Beams
  * Push Webhook
* In-app Notification Center: Novu provides you with a set of APIs and components to create rich customized notification center experiences:
  * React component
  * Angular component
  * Vue component
  * Web component
  * iFrame embed
  * Custom styling
  * Headless notification center

## Subscribers

Subscribers are entities designated to receive the notifications you send. Each subscriber in Novu is uniquely identified by their `subscriberId`.

## Actor

An `actor` refers to a user or subscriber who initiates actions that trigger events within the system. Each actor is uniquely identified by an "actorId," also known as "subscriberId," which distinguishes them from others.

Actors hold user-related variables, such as subscriber properties and data payload, containing information like names, emails, and custom data.

Additionally, actors can enhance notifications by allowing their avatars to be displayed, improving the context and identification of notifications.

Including actors in event data enables precise tracking and personalization of actions and events in the Novu platform.

## Workflow

Workflow templates define the flow of messages sent to subscribers.

## Topics

Topics facilitate bulk notifications to multiple subscribers simultaneously, streamlining communication.

## Digest Engine

The digest engine aggregates multiple trigger events into a single message, ensuring efficient communication.

## Delay Actions

Delay actions introduce time intervals between workflow steps, optimizing message delivery timing.

## Step Filter

Step filters customize workflow by specifying notification criteria, enhancing communication efficiency.

## Organizations

Organizations allow separation of notifications across multiple products, managed through the Novu web dashboard.

<Frame>
  <img />
</Frame>

## Environments

Novu runs all your requests in the context of an environment. By default, Novu creates two environments when your account was created, `development` and `production`.

1. `Development environment`: The development environment is used for testing purposes and validating notification changes prior to committing them to the production environment.
2. `Production environment`: It will be your live/production environment, you cannot make changes to this environment directly. You will first have to make the changes in the `development` environment and then promote it to `production`. This is a read-only environment.

## Data associated with an environment

* Subscribers (can’t be promoted to production)
* Workflows (can be promoted to production)
* Messages
* Execution logs
* Connected integrations (can’t be promoted to production)
* Notification feeds (can be promoted to production)
* Brand-related assets and settings

## Team members

Members of a team have access to the Novu web dashboard. This allows you to have individuals work on and manage templates and notifications.

## Layouts

Layouts are HTML designs or structures to wrap the content of email notifications. Layouts can be manipulated and assigned to new or existing workflows within the Novu platform, allowing users to create, manage, and assign these layouts to workflows, so they can be reused to structure the appearance of notifications sent through the platform.


# Idempotent Requests
Source: https://v0.x-docs.novu.co/additional-resources/idempotency

Retry API requests fearlessly, ensuring the operation performs just once!

Our platform has a seamless integration of optional [idempotent](https://en.wikipedia.org/wiki/Idempotence) requests for `POST` and `PATCH` operations.
This integration closely adheres to the [Idempotency-key ietf draft](https://datatracker.ietf.org/doc/draft-ietf-httpapi-idempotency-key-header/).
These idempotent operations deliver the same result regardless of the number of requests made, using an idempotent key.

Leveraging this feature guarantees the safety and reliability of your requests, especially in cases where network or communication issues might inject uncertainty into request outcomes.
Idempotent requests are <b>critical</b> for workflows that require the insurance of only one successful delivery request.

<Note>
  This feature was introduced in version 0.22.0 and is fully operable from 0.24.0 and beyond. Currently, the Idempotency headers are not enabled on the cloud platform but are available for self-hosting.
</Note>

<Warning>
  Please be aware that idempotency might not be supported in all community SDKs.
</Warning>

## How to Perform an Idempotent Request with SDKs

Supporting SDKS will implement Idempotency for you as long as you have retries turned on.
Not only is this seamless but it also ensures that no event request is dropped provided that your system stays up.

<Note>
  Idempotency is only implemented for /events/trigger endpoint.
</Note>

### Idempotent request with api

To make an idempotent request, simply include the `Idempotency-Key: <key>` in your request header.
This key should be a unique client-generated value, boasting enough entropy to prevent collisions;
we recommend a collision-resistant Unique Identifier, such as UUIDv7, CUID, or ULID, as your idempotency keys.

## Understanding Response Replay

Our API stores the status code and response body from your initial idempotent request.
This way if an identical idempotency key appears in a later request,
the API will replay the saved response from the original request - even if it involves client or server error responses.

In the event of a response replay, the response will carry an `Idempotency-Replay: true` header.

## Idempotent Request Responces

Here are some unique pieces constraints you should be aware of especially if you are not using the sdk:

1. A `<key>` exceeding 255 characters will trigger a `400 Bad Request` error.
2. An inconsistent request body compared to the initial request will return a `422 Unprocessable Entity` error.
3. A ongoing processing of the initial request that hasn't yet responded will result in a `409 Conflict` error. This will include a `Retry-After` header.

<Note>
  Results will <b>not</b> saved if an API request is invalid.
</Note>

## Expiring Keys

All idempotency keys are ensured to be automatically removed once they are 24 hours and 1 minute old.
After this period, the reused key will be treated as a new request and response.

## Practical Examples

### Example 1 - No idempotency

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>");

    await novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
      to: {
        subscriberId: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      },
      payload: {
        name: "Hello World",
      },
      actor: "actorId",
      tenant: "tenantIdentifier",
    });
    ```
  </Tab>
</Tabs>

### Example 2 - Idempotency Active

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    import { Novu } from '@novu/node';

    const novu = new Novu("<NOVU_API_KEY>", {
        retryConfig: {
            retryMax: 5
        }
    });

    // This request is now idempotent
    await novu.trigger("<WORKFLOW_TRIGGER_IDENTIFIER>", {
      to: {
        subscriberId: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      },
      payload: {
        name: "Hello World",
      },
      actor: "actorId",
      tenant: "tenantIdentifier",
    });
    ```
  </Tab>
</Tabs>

## References

* [https://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/eo](https://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/eo)


# Blog Posts, Articles & Videos
Source: https://v0.x-docs.novu.co/additional-resources/posts-videos-and-articles

Blog posts, articles, and videos

## Blog Posts / Articles

* [🪄✨Building a blog with a liking feature using React, Hanko and Novu 🔥](https://dev.to/novu/building-a-blog-with-a-liking-feature-using-react-hanko-and-novu-1m81)
* [How to add In-App notifications to any web app!](https://dev.to/novu/how-to-add-in-app-notifications-to-any-web-app-1b4n)
* [How To Add In-App Notifications To Your Angular App](https://dev.to/novu/how-to-add-in-app-notifications-to-your-angular-app-2dp3)
* [Creating A Hot New Food Delivery App with Novu](https://dev.to/novu/creating-a-hot-new-food-delivery-app-with-novu-2e75)

## Videos

* [How to add In-App Notifications to your Web app with Novu](https://www.youtube.com/watch?v=KD8zoUb132k)
* [Subscriber (User) Management & Bulk Import Guide](https://www.youtube.com/watch?v=m5nhYEuz86I\&t=92s)
* [Workflow Optimization with Delay Actions](https://www.youtube.com/watch?v=kCMB-WdbzJo)

## External Resources

* [Simplify configuration management with Novu and Configu](https://configu.com/blog/video-first-steps-with-configu/)
* [Vercel and Novu integration](https://vercel.com/integrations/novu)
* [Novu is building open-source notification infrastructure for developers](https://venturebeat.com/business/novu-is-building-open-source-notification-infrastructure-for-developers/)
* [Novu - An open-source notification infrastructure for developers](https://reactjsexample.com/-f0-9f-9a-80-open-source-notification-infrastructure-for-products/)
* [Novu Tackles Notification Infrastructure Management](https://thenewstack.io/novu-tackles-notification-infrastructure-management/)
* [Novu: Omni-channel notification infrastructure for developers](https://www.decibel.vc/articles/novu-omni-channel-notification-infrastructure-for-developers)


# Bulk trigger event
Source: https://v0.x-docs.novu.co/api-reference/events/bulk-trigger-event

post /v1/events/trigger/bulk

      Using this endpoint you can trigger multiple events at once, to avoid multiple calls to the API.
      The bulk API is limited to 100 events per request.
    

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.events.bulkTrigger([
    {
      name: "<WORKFLOW_TRIGGER_IDENTIFIER>",
      to: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload: {
        customKey: "customValue",
        customKey1: {
          nestedkey1: "nestedValue1"
        }
      },
      overrides: {
        email: {
          from: "support@novu.co"
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    },
    {
      name: "<WORKFLOW_TRIGGER_IDENTIFIER>",
      to: "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload: {
        customKey: "customValue",
        customKey1: {
          nestedkey1: "nestedValue1"
        }
      },
      overrides: {
        email: {
          from: "support@novu.co"
        }
      },
      // actorId is subscriberId of actor
      actor: "actorId"
      tenant: "tenantIdentifier"
    }
  ])
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->bulkTriggerEvent([
      [
          'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>', 
          'to' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>', 
          'payload' => ['customVariables' => 'Hello']
      ],
      [
          'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>', 
          'to' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>', 
          'payload' => ['customVariables' => 'World']
      ],
  ])->toArray();
  ```

  ```bash cURL theme={null}

  curl -X POST https://api.novu.co/v1/events/trigger/bulk \
    -H "Authorization: ApiKey <NOVU_API_KEY>" \
    -H "Content-Type: application/json" \
    -d '{
      "events": [
        {
          "name": "<WORKFLOW_TRIGGER_IDENTIFIER>",
          "to": {
            "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
            "email": "john@doemail.com"
          },
          "payload": {
            "customKey": "customValue",
            "customKey1": {
              "nestedkey1": "nestedValue1"
            }
          },
          "overrides": {
            "email": {
              "from": "support@novu.co"
            }
          },
          "actor": "actorId",
          "tenant": "tenantIdentifier"
        },
        {
          "name": "<WORKFLOW_TRIGGER_IDENTIFIER>",
          "to": {
            "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
            "email": "janet@doemail.com"
          },
          "payload": {
            "customKey": "customValue",
            "customKey1": {
              "nestedkey1": "nestedValue1"
            }
          },
          "overrides": {
            "email": {
              "from": "support@novu.co"
            }
          },
          "actor": "actorId",
          "tenant": "tenantIdentifier"
        }
      ]
    }'


  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'events' => [
          {
              'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
              'payload' => { # optional
                  'first-name' => 'Adam' # optional
              },
              'to' => {
                  'subscriberId' => '7789'
              },
              'transactionId' => '89kjfke9893' #optional
          },
          {
              'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
              'payload' => { # optional
                  'last-name' => 'Eve' # optional
              },
              'to' => {
                  'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
              },
              'transactionId' => 'sw900999as' #optional
          }
      ]
  }
  client.trigger_bulk_event(payload)
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
  	apiKey := "<NOVU_API_KEY>"
  	ctx := context.Background()

  	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

      event1 := novu.BulkTriggerOptions{
          Name: []string{"<WORKFLOW_TRIGGER_IDENTIFIER>"},
          To: map[string]interface{}{
              "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
              "email":        "john@doemail.com",
  	    },
          Payload: map[string]interface{}{
              "name": "Hello World",
              "organization": map[string]interface{}{
                  "logo": "https://happycorp.com/logo.png",
              },
  	    }
      }
      event2 := novu.BulkTriggerOptions{
          Name: []string{"<WORKFLOW_TRIGGER_IDENTIFIER>"},
          To: map[string]interface{}{
              "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
              "email":        "janet@doemail.com",
  	    },
          Payload: map[string]interface{}{
              "name": "Hello World",
              "organization": map[string]interface{}{
                  "logo": "https://happycorp.com/logo.png",
              },
  	    }
      }

      triggerPayload := []novu.BulkTriggerOptions{ event1, event2}

  	resp, err := novuClient.EventApi.TriggerBulk(ctx, triggerPayload)

  	if err != nil {
  		log.Fatal("novu error", err.Error())
  		return
  	}
  }
  ```

  ```python Python theme={null}
  from novu.dto.event import InputEventDto
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  event_1 = InputEventDto(
      name="<WORKFLOW_TRIGGER_IDENTIFIER>",  # The workflow ID is the slug of the workflow name. It can be found on the workflow page.
      recipients="<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload={},  # Your custom Novu payload goes here
  )
  event_2 = InputEventDto(
      name="<WORKFLOW_TRIGGER_IDENTIFIER>",
      recipients="<UNIQUE_SUBSCRIBER_IDENTIFIER>",
      payload={},
  )

  novu = EventApi(url, api_key).trigger_bulk(
      events=[event1,event2]
  )
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.events.requests.TriggerEventRequest;
  import co.novu.api.events.pojos.BulkTriggerEventRequest;
  import co.novu.api.events.responses.BulkTriggerEventResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest = new SubscriberRequest();
          subscriberRequest.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest.setFirstName("<FIRST_NAME>");
          subscriberRequest.setLastName("<LAST_NAME>");
          subscriberRequest.setPhone("<PHONE_NUMBER>");
          subscriberRequest.setAvatar("<AVATAR>");
          subscriberRequest.setSubscriberId("<SUBSCRIBER_ID>");

          TriggerEventRequest triggerEventRequest1 = new TriggerEventRequest();
          triggerEventRequest1.setName("<NAME>");
          triggerEventRequest1.setTo(subscriberRequest);
          triggerEventRequest1.setPayload(Collections.singletonMap("<CUSTOM_VARIABLE_NAME>", "<CUSTOM_VARIABLE_VALUE>"));
          
          TriggerEventRequest triggerEventRequest2 = new TriggerEventRequest();
          triggerEventRequest2.setName("<NAME>");
          triggerEventRequest2.setTo(subscriberRequest);
          triggerEventRequest2.setPayload(Collections.singletonMap("<CUSTOM_VARIABLE_NAME>", "<CUSTOM_VARIABLE_VALUE>"));

          BulkTriggerEventRequest bulkTriggerEventRequest = new BulkTriggerEventRequest();
          bulkTriggerEventRequest.setEvents(Arrays.asList(triggerEventRequest1, triggerEventRequest2));

          BulkTriggerEventResponse response = novu.bulkTriggerEvent(bulkTriggerEventRequest);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  var payload = new List<EventTriggerDataDto>()
  {
      new()
      {
          EventName = "<WORKFLOW_TRIGGER_IDENTIFIER>",
          To = { SubscriberId = "<UNIQUE_SUBSCRIBER_IDENTIFIER>"},
          Payload = new TestRecord(){ Message = "Hello"}
      },
      new()
      {
          EventName = "<WORKFLOW_TRIGGER_IDENTIFIER>",
          To = { SubscriberId = "<UNIQUE_SUBSCRIBER_IDENTIFIER>"},
          Payload = new TestRecord(){ Message = "World"}
      },
  };

  var trigger = await novu.Event.TriggerBulkAsync(payload);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": [
          {
              "acknowledged": true,
              "status": "processed",
              "transactionId": "string"
          }
      ]
  }
  ```
</ResponseExample>


# Trigger event
Source: https://v0.x-docs.novu.co/api-reference/events/trigger-event

post /v1/events/trigger

    Trigger event is the main (and only) way to send notifications to subscribers. The trigger identifier is used to match the particular workflow associated with it. Maximum number of recipients can be 100. Additional information can be passed according the body interface below.
    To prevent duplicate triggers, you can optionally pass a **transactionId** in the request body. If the same **transactionId** is used again, the trigger will be ignored. The retention period depends on your billing tier.

<Warning>
  Enter your API key in the `Authorization` field like the example shown below:

  E.g `ApiKey 18d2e625f05d80e`
</Warning>

<RequestExample>
  ```javascript Node.js theme={null}
  import { Novu } from '@novu/node';

  const novu = new Novu("<NOVU_API_KEY>");

  await novu.trigger('<WORKFLOW_TRIGGER_IDENTIFIER>',
    {
      to: {
        subscriberId: '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
        email: 'john@doemail.com',
        firstName: 'John',
        lastName: 'Doe',
      },
      payload: {
        name: "Hello World",
        organization: {
          logo: 'https://happycorp.com/logo.png',
        },
      },
    }
  );
  ```

  ```php PHP theme={null}
  use Novu\SDK\Novu;

  $novu = new Novu(<NOVU_API_KEY>);

  $novu->triggerEvent([
      'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
      'payload' => ['customVariables' => 'Hello'],
      'to' => [
          'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>',
          'phone' => '07983882186'
      ]
  ])->toArray();
  ```

  ```bash cURL theme={null}

  curl -X POST https://api.novu.co/v1/events/trigger \
    -H "Authorization: ApiKey <NOVU_API_KEY>" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "<WORKFLOW_TRIGGER_IDENTIFIER>",
      "to": {
        "subscriberId": "<UNIQUE_SUBSCRIBER_IDENTIFIER>",
        "email": "john@doemail.com",
        "firstName": "John",
        "lastName": "Doe"
      },
      "payload": {
        "name": "Hello World",
        "organization": {
          "logo": "https://happycorp.com/logo.png"
        }
      }
    }'
  ```

  ```ruby Ruby theme={null}
  require 'novu'

  client = Novu::Client.new('<NOVU_API_KEY>')

  payload = {
      'name' => '<WORKFLOW_TRIGGER_IDENTIFIER>',
      'payload' => { # optional
          'first-name' => 'Adam' # optional
      },
      'to' => {
          'subscriberId' => '<UNIQUE_SUBSCRIBER_IDENTIFIER>'
      },
      'transactionId' => '89kjfke9893' #optional
  }

  client.trigger_event(payload)
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	novu "github.com/novuhq/go-novu/lib"
  	"log"
  )

  func main() {
  	subscriberID := "<UNIQUE_SUBSCRIBER_IDENTIFIER>"
  	apiKey := "<NOVU_API_KEY>"
  	eventId := "<WORKFLOW_TRIGGER_IDENTIFIER>"

  	ctx := context.Background()
  	to := map[string]interface{}{
  		"lastName":     "Doe",
  		"firstName":    "John",
  		"subscriberId": subscriberID,
  		"email":        "john@doemail.com",
  	}

  	payload := map[string]interface{}{
  		"name": "Hello World",
  		"organization": map[string]interface{}{
  			"logo": "https://happycorp.com/logo.png",
  		},
  	}

  	data := novu.ITriggerPayloadOptions{To: to, Payload: payload}
  	novuClient := novu.NewAPIClient(apiKey, &novu.Config{})

  	resp, err := novuClient.EventApi.Trigger(ctx, eventId, data)

  	if err != nil {
  		log.Fatal("novu error", err.Error())
  		return
  	}
  }
  ```

  ```python Python theme={null}
  from novu.api import EventApi

  url = "https://api.novu.co"
  api_key = "<NOVU_API_KEY>"

  novu = EventApi(url, api_key).trigger(
      name="<WORKFLOW_TRIGGER_IDENTIFIER>",  # This is the Workflow ID. It can be found on the workflow page.
      recipients="<UNIQUE_SUBSCRIBER_IDENTIFIER>", # The subscriber ID can be gotten from the dashboard.
      payload={},  # Your custom Novu payload goes here
  )
  ```

  ```java Java theme={null}
  import co.novu.common.base.Novu;
  import co.novu.api.common.SubscriberRequest;
  import co.novu.api.events.requests.TriggerEventRequest;
  import co.novu.api.events.responses.TriggerEventResponse;

  public class Main {
      public static void main(String[] args) {
          String apiKey = "<NOVU_API_KEY>";

          Novu novu = new Novu(apiKey);

          SubscriberRequest subscriberRequest = new SubscriberRequest();
          subscriberRequest.setEmail("<EMAIL_ADDRESS>");
          subscriberRequest.setFirstName("<FIRST_NAME>");
          subscriberRequest.setLastName("<LAST_NAME>");
          subscriberRequest.setPhone("<PHONE_NUMBER>");
          subscriberRequest.setAvatar("<AVATAR>");
          subscriberRequest.setSubscriberId("<SUBSCRIBER_ID>");

          TriggerEventRequest triggerEventRequest = new TriggerEventRequest();
          triggerEventRequest.setName("<NAME>");
          triggerEventRequest.setTo(subscriberRequest);
          triggerEventRequest.setPayload(Collections.singletonMap("<CUSTOM_VARIABLE_NAME>", "<CUSTOM_VARIABLE_VALUE>"));
          
          TriggerEventResponse response = novu.triggerEvent(triggerEventRequest);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Novu.DTO;
  using Novu.Models;
  using Novu;

  var novuConfiguration = new NovuClientConfiguration
  {
      /** 
      * Defaults to https://api.novu.co/v1 
      */
      Url = "https://novu-api.my-domain.com/v1", 
      ApiKey = "12345",
  };

  var novu = new NovuClient(novuConfiguration);

  public class OnboardEventPayload
  {
    [JsonProperty("username")]
    public string Username { get; set; }

    [JsonProperty("welcomeMessage")]
    public string WelcomeMessage { get; set; }
  }

  var onboardingMessage = new OnboardEventPayload
  {
    Username = "jdoe",
    WelcomeMessage = "Welcome to novu-dotnet"
  };

  var payload = new EventTriggerDataDto()
  {
    EventName = "onboarding",
    To = { SubscriberId = "subscriberId" },
    Payload = onboardingMessage
  };

  var trigger = await novu.Event.Trigger(payload);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
      "data": {
          "acknowledged": true,
          "status": "processed",
          "transactionId": "string"
      }
  }
  ```
</ResponseExample>

<Accordion title="Idempotent nature of transactionId">
  The `transactionId` within Novu is a unique identifier that is used to ensure the idempotent nature of notification delivery.

  When you trigger an event to send a notification, you have the option to provide a `transactionId`. If you do not provide one, Novu will generate a UUID for you.

  **This identifier is particularly useful for preventing the same notification from being sent multiple times in case the trigger event is inadvertently called more than once.**

  By leveraging the `transactionId`, you can make idempotent requests, which means if the same `transactionId` is used in another request, Novu's API will recognize it and will not send the same notification again.

  <Note>
    This upholds the principle of idempotency, ensuring that the effect of the operation is the same, no matter how many times the request is repeated with the same `transactionId`.
  </Note>
</Accordion>


# API Overview
Source: https://v0.x-docs.novu.co/api-reference/overview

In this page you can learn about how to work with Novu's API

<Note>
  It's important to note that our API and backend SDK are intended for use
  exclusively in server-side applications. **Attempting to use them in a
  client-side application will result in Cross-Origin Resource Sharing (CORS)
  errors.** This restriction ensures the security and integrity of our services.
</Note>

## Authentication

Authentication for the Novu API involves the use of an API Key, which is a secure credential that is tied to your Novu account. This key should be included in the header of the request in the Authorization field as a string prefixed with 'ApiKey '.

```curl theme={null}
--header 'Authorization: ApiKey <NOVU_API_KEY>'
```

For example, when using Novu in a Node.js application, the Novu package should be imported and initialized with the API key, as shown in this snippet:

```javascript theme={null}
import { Novu } from "@novu/node";
const novu = new Novu("<NOVU_API_KEY>");
```

Replace `<NOVU_API_KEY>` with your actual API Key, available in the API Key section of the Novu Dashboard.

<Warning>
  It is advised not to hardcode your credentials in a file in production
  environments. Use environment variables instead.
</Warning>

## API Endpoints

Novu provides a multitude of API endpoints that enable a variety of functionalities.
the base URL for the Novu API is `https://api.novu.co/v1`.

<Note>
  We offer two API options: the US API and the EU API. By default, our API documentation refers to the US API, which can be accessed at: [https://api.novu.co/v1](https://api.novu.co/v1).

  If you require the EU version, you can access it here: [https://eu.api.novu.co/v1](https://eu.api.novu.co/v1).
</Note>

For instance, to get tenant information, the endpoint to use would include the tenant's identifier and look like this `https://api.novu.co/v1/tenants/{identifier}`.


# API Rate Limiting
Source: https://v0.x-docs.novu.co/api-reference/rate-limiting

In this page you can learn about how rate limiting works with Novu's API

<Note>
  This feature is available from v0.22.0.
</Note>

Rate limiting is an essential functionality for establishing a robust and resilient system. It safeguards system resources from being misused by malicious actors or being monopolized by one client.

A variable-cost token bucket rate limited algorithm has been added to provide the capability for different API controllers and methods to have a varying cost. It also lays a foundation for dynamic costing of resource consumption.

## Limits

The following limits apply to each category of the Novu system. Each category has an independent bucket of rate-limit tokens to consume.
Bulk requests have a rate limit cost of 100 times the base limit and consume from the same token pool. For example, the free tier would allow a combined maximum of 10 standard trigger events and 2 bulk trigger events in the same 1-second window.

| Category      | Free   | Business | Endpoints                                                            |
| ------------- | ------ | -------- | -------------------------------------------------------------------- |
| Events        | 60 rps | 600 rps  | Trigger                                                              |
| Configuration | 15 rps | 150 rps  | Subscribers, Topics, Tenants                                         |
| Global        | 30 rps | 300 rps  | All other endpoints consume rate limiting tokens from this category. |


# Add a new provider
Source: https://v0.x-docs.novu.co/community/add-a-new-provider

Steps to add a new provider to Novu

Interested in expanding Novu's capabilities? By contributing to our growing ecosystem, you can enhance Novu's reach and impact.

## How to add a new provider?

Novu currently supports five channels `in_app`, `push`, `email`, `chat` and `sms`.

For `in_app` we support only our own provider, so new providers cannot be added to this channel. For the other four channels, we support the integration of external providers. This guide will help in adding new providers for any of these 4 channels.

In this guide, we are adding a new provider for the email channel, but all of the mentioned steps are similar for other channels as well.

## Description

Providers allow us to handle message delivery over multiple channels.

We have multiple providers for each channel (SMS, Email, Push and Chat). To get started with adding a new provider let's look at setting up our repository.

## Requirements

* Node.js version v20.8.1
* MongoDB
* Redis
* **(Optional)** pnpm - Needed if you want to install new packages
* **(Optional)** localstack (required only in S3 related modules)

Need help installing the requirements? [Read more here](/community/run-in-local-machine)

<Note> We have used pnpm package manager in this guide. You can use npm as well. </Note>

## Initialization

Fork the novu repository and clone it in your local machine.

```shell theme={null}
git clone https://github.com/<'YOUR_GITHUB_USER_NAME'>/novu.git
```

To set up the repository, run the initial setup command:

```shell theme={null}
pnpm run setup:project
```

At the root of the project build the `node` package to get started.

```shell theme={null}
cd packages/node && pnpm run build
```

## Generate provider

After the project is initialized, a new provider can be generated using the below command.

```shell theme={null}
pnpm run generate:provider
```

<Note> Use the above command at the root of the project. </Note>

Choose the provider type.

```shell theme={null}

? What type
❯ EMAIL
  SMS
  PUSH
  CHAT
```

Use `up` and `down` arrow to switch `channel` type and press `enter` to select.

For this example, we will be selecting `EMAIL` as our provider type. The name for our provider will be `example-provider`.

```
? Write the provider name`kebab-cased` (e.g. proton-mail, outlook365, yahoo-mail): example-provider
```

Make sure your selected name is not conflicting with our existing provider's name. Boilerplate files for this new `example-provider` is generated in your local machine project.

> In above example, we have given our provider name as example-provider for simplicity. If provider you want to add have name as twilio, don't use twilio-provider as name, instead use twilio only. If one provider supports multiple channels like infobip supports both sms and email channels, use infobip-email or infobip-sms to differentiate these providers.

Once our `example-provider` is generated we will need to begin working from within `packages/providers/src/lib/example-provider` directory. Make sure to write the test for this new provider.

```ts packages/providers/src/lib/example-provider/example-provider.provider.ts theme={null}
import {
  ChannelTypeEnum,
  ISendMessageSuccessResponse,
  IEmailOptions,
  IEmailProvider,
} from '@novu/stateless';

export class ExampleProviderEmailProvider implements IEmailProvider {
  id = 'example-provider'
  channelType = ChannelTypeEnum.EMAIL as ChannelTypeEnum.EMAIL;

  constructor(
    private config: {
      apiKey: string;
    }
  ) {}

  async sendMessage(options: IEmailOptions): Promise<ISendMessageSuccessResponse> {
    return {
      id: 'id_returned_by_provider',
      date: 'current_time'
  }
}
```

### Template test case for `example-provider`.

```ts packages/providers/src/lib/example-provider/example-provider.provider.sepc.ts theme={null}
import { ExampleProviderEmailProvider } from './example-provider.provider';

test('should trigger example-provider library correctly', async () => {});
```

<Info> Add the provider's SDK as a dependency in the provider's package.json file. Run `pnpm run setup:project` to build all dependencies again. Use this new sdk method to complete the provider's `sendMessage` function. Check the **[reference links for adding new providers](#reference-for-adding-new-providers)** section for each channel's provider example. </Info>

### Add provider logos

In order to present this new provider in the `integration store` we need logos in dark and light mode. Add dark color svg logo in  `apps/web/public/static/images/providers/dark/sqaure` directory and light color svg logo in  `apps/web/public/static/images/providers/light/sqaure` directory.

Use the provider name as the file name. The sample name for our above-added provider is `example-provider.svg`.

## Add config items to the list

In order to build the UI integration store, we need to provide it list of all provider integrations. This part is made up of two parts:

* Create credentials config
* Add ProviderId Enum
* Add provider configuration to the providers list

### 1. Create credentials config

Every provider requires some credentials to create an instance. Novu will add these credentials fields in the integration store provider's form so that users can use their credentials to connect to their preferred provider to use for that channel notification. For example, in the above added `example-provider`, we have only one credential `ApiKey`. We will need to add a config object for `example-provider` with all existing provider's configs like below.

```tsx libs/shared/src/consts/providers/credentials/provider-credentials.ts theme={null}
export const exampleProviderConfig: IConfigCredentials[] = [
  {
    key: CredentialsKeyEnum.ApiKey,
    displayName: "API Key",
    description: "This is API key for example provider",
    type: "text",
    required: true,
  },
  ...mailConfigBase,
];
```

1. Here the `key` is of type `CredentialsKeyEnum`.

> If a new key is added, add this key at these 3 places:-
>
> * In `CredentialsKeyEnum` at file `libs/shared/src/consts/providers/provider.enum.ts`
> * In `CredentialsDto` at file `apps/api/src/app/integrations/dtos/credentials.dto.ts`
> * In `credentials` field of `integrationSchema` at file `libs/dal/src/repositories/integration/integration.schema.ts`

2. `displayName` is a human-friendly easy to understand name which will be shown in the provider integration form for this credential.
3. `description` is a field that can be used to share more information about the credential.
4. `type` here means text field type. this can be a string for text, text for text-area, or a switch for the toggle.
5. `required` is of boolean type.
6. `mailConfigBase` is an object having default credentials required by any `email` provider. Make sure not to add duplicate providers which are already there in `mailConfigBase`. In the case of another channel provider, we will use that channel config base in place of `mailConfigBase`.

> A credential can be made secret by adding in ./secure-credentials.ts file.

### 2. Add ProviderId Enum

Add this new provider id in the respective channel provider id enum in file `libs/shared/src/consts/providers/provider.enum.ts`. As our `example-provider` is of email type, add this in `EmailProviderIdEnum` with all existing providers like below

```tsx libs/shared/src/consts/providers/provider.enum.ts theme={null}
export enum EmailProviderIdEnum {
  ExampleProvider = "example-provider",
}
```

### 3. Add provider to providers list

Now we need to add the provider data to the list located at `libs/shared/src/consts/providers/channels/email.ts`. Note that the `id` is the provider's name, `displayName` is the provider's name in Pascal's case, `credentials` are the ones we created in the previous step, `logoFileName` should be as it was on the adding logo step (with the format type included).

```tsx libs/shared/src/consts/providers/channels/email.ts theme={null}
{
  id: 'example-provider',
  displayName: 'Example Provider',
  channel: ChannelTypeEnum.EMAIL,
  credentials: exampleProviderConfig,
  // Use valid documentation link
  docReference: 'https://docs.example-provider.com/',
  logoFileName: { light: 'example-provider.svg', dark: 'example-provider.svg' }
}
```

## Add provider handler in the API

### 1. Adding the provider dependency in the application-generic package

In the previous step, we created a standalone provider package that will be published to NPM. However currently in our development environment, it is not yet published. In order to use it locally please go to the `package.json` located in `packages/application-generic/package.json` and add it manually to the dependencies list: `"@novu/<NEW_PROVIDER_NAME>": "^<VERSION>"`

> Please note that the provider name and version can be found from the provider package.json you created earlier.

After adding the dependency run `pnpm run setup:project` from the root of the mono repo. so, it can create the required symlinks for the newly created package.

### 2. Create a provider handler

In order to map internally the different providers’ credentials, we need to add a provider handler at the respective channel handlers located. For Email, it can be found at `apps/packages/application-generic/src/factories/mail/handlers`. Other channel handlers can also be found here.

Create a new file `example-provider.handler.ts` here with the following code

```tsx packages/application-generic/src/factories/mail/handlers/example-provider.handler.ts theme={null}
import { ChannelTypeEnum } from "@novu/shared";
import { ExampleProviderEmailProvider } from "@novu/example-provider";
import { BaseHandler } from "./base.handler";

export class ExampleProviderHandler extends BaseHandler {
  constructor() {
    super("example-provider", ChannelTypeEnum.EMAIL);
  }

  buildProvider(credentials, from: string) {
    const config: { apiKey: string } = { apiKey: credentials.apiKey };

    this.provider = new ExampleProviderEmailProvider(config);
  }
}
```

Add this line given below to export this handler

```tsx packages/application-generic/src/factories/mail/handlers/index.ts theme={null}
export * from "./example-provider.handler";
```

### 3. Add handler to factory

The last step is to initialize the handler in the factory located in `packages/application-generic/src/factories/mail/mail.factory.ts`

```tsx packages/application-generic/src/factories/mail/mail.factory.ts theme={null}
import { ExampleProviderHandler } from "./handlers";

export class MailFactory {
  handlers: IMailHandler[] = [new ExampleProviderHandler()];
}
```

### Final Steps

Now, build the project again using this command

```shell theme={null}
pnpm run setup:project
```

Run novu in your local machine. Read [here](/community/run-in-local-machine) to learn on how to run novu on a local machine and test this new provider.

Run the below command in the root of the project to run the providers test

```shell theme={null}
pnpm run test:providers
```

If everything is working fine without any error, commit your local branch changes, push this branch and create a new pull request to our main repo.

Hurray 🎉! You have successfully added a new provider in Novu!

<Info>️ In this guide, we have used only one credential `apiKey` for our `example-provider`. This is for reference purposes only. A provider can have more than one credential as per its `SDK` requirements. At each step, you will need to add all credentials carefully. Check providers referenced below for more information. </Info>

### Reference for Adding New Providers

* [SendGrid Email Provider](https://github.com/novuhq/novu/blob/next/providers/sendgrid/src/lib/sendgrid.provider.ts)
* [Twilio SMS Provider](https://github.com/novuhq/novu/blob/next/providers/twilio/src/lib/twilio.provider.ts)
* [FCM Push Provider](https://github.com/novuhq/novu/blob/next/providers/fcm/src/lib/fcm.provider.ts)
* [Slack Chat Provider](https://github.com/novuhq/novu/blob/next/providers/slack/src/lib/slack.provider.ts)
* [Resend - How to add an Email Provider to Novu](https://dev.to/novu/resend-how-to-add-an-email-api-provider-to-novu-49cd)


# Monorepo Structure
Source: https://v0.x-docs.novu.co/community/monorepo-structure

Learn the components of Novu's monorepo

In this guide, we will explore the Novu mono-repo structure and high-level structure of the different libraries and services we use.

## Setting up the monorepo

Novu uses [PNPM](https://pnpm.js.org/) as its package manager, and [NX](https://nx.dev/) as its build CLI tool. PNPM reduces the installation time and generates symlinks for all the internal packages we use.

To initialize the monorepo, run the following command from the root of the project:

```bash theme={null}
npm run setup:project
```

This will:

* run `pnpm install`, which will download all the needed dependencies and create symlinks for packages.
* copy the `.env.example` file to the `.env` file for the API service.
* execute the `npm run build` command to build all the dependency trees locally.

For additional information on running Novu locally, visit the [run locally](https://docs.novu.co/community/run-in-local-machine) guide.

## Apps

The `apps` folder contains high-level applications and APIs. The app's outputs usually contain deployable units that a user can interact with either as an API or as a web/cli application.

<Steps>
  <Step title="API">
    The API package is our main service for handling backend logic. It handles anything from authentication, authorization, workflow management, triggering events, etc... This is where the Novu business logic is handled.
  </Step>

  <Step title="WS aka Web Socket">
    This is the WebSocket NestJs server which connects to the widget and provides real-time updates about new notifications to the widget consumer.
  </Step>

  <Step title="Web aka Admin Panel">
    This is the Novu admin panel which is used to visually communicate with the API. You can configure workflows, manage content, enable or disable notifications, visually track the notification activity feed, etc...

    The `WEB` project is a create-react-app built, well, with React. 😄
  </Step>

  <Step title="Widget">
    This is the client of our embeddable notification center widget. It is consumed mainly with the embed script in an Iframe. We can access it on port 4500 to interact with it directly.
  </Step>

  <Step title="Worker">
    This is our service for managing and handling workers.
  </Step>
</Steps>

## Libs

<Steps>
  <Step title="@novu/dal">
    The `DAL` is our Data-Access-Layer. This is our connection to the DB service and wraps MongoDB and mongoose. When another service or API needs to consume the DB, it does not do that directly but uses the DAL as an interface. Importing `mongoose` directly outside the `dal` is not allowed.
  </Step>

  <Step title="@novu/testing">
    This is a utility library that contains testing helpers. The testing helpers can generate test sessions and other functionality for e2e and unit-tests between our services.
  </Step>

  <Step title="@novu/shared">
    The shared library contains reusable code and typescript interfaces between client and server packages. Code in the shared library should not contain any sensitive content because it can be accessed and downloaded by the web or other clients.
  </Step>

  <Step title="@novu/embed">
    This is the connector between our client's web app and the widget project. It’s a small shim script that generates an iframe and attaches it to a client-specified div to host the notification widget.

    If you are familiar with the Google Analytics embedded snippet or intercom-like embeddings, it uses the same mechanics.
  </Step>
</Steps>

## Packages (on npm)

<Steps>
  <Step title="@novu/node">
    A Standalone Node.js wrapper around the Novu API. Exists to provide type-safe and easier access to the different API endpoints Novu exposes (Triggers, subscribers, etc…).
  </Step>

  <Step title="@novu/nest">
    A Nest.js wrapper around the `@novu/node` package was created by the community to easily interact with the core library from a nest project. Also released on NPM as a package.
  </Step>

  <Step title="@novu/notification-center">
    React component library that contains widget bell with the notification center. Can get override of components like ‘bell icon’, and ‘notification center’.
  </Step>
</Steps>

## Providers

These are the API wrappers created by the community to wrap communication providers in the following channels:

Novu provides a single API to manage providers across multiple channels with a simple-to-use interface.

### 💌 Email

* [Sendgrid](https://github.com/novuhq/novu/tree/main/providers/sendgrid)
* [Netcore](https://github.com/novuhq/novu/tree/main/providers/netcore)
* [Mailgun](https://github.com/novuhq/novu/tree/main/providers/mailgun)
* [SES](https://github.com/novuhq/novu/tree/main/providers/ses)
* [Postmark](https://github.com/novuhq/novu/tree/main/providers/postmark)
* [Custom SMTP](https://github.com/novuhq/novu/tree/main/providers/nodemailer)
* [Mailjet](https://github.com/novuhq/novu/tree/main/providers/mailjet)
* [Mandrill](https://github.com/novuhq/novu/tree/main/providers/mandrill)
* [SendinBlue](https://github.com/novuhq/novu/tree/main/providers/sendinblue)

### 📞 SMS

* [Twilio](https://github.com/novuhq/novu/tree/main/providers/twilio)
* [Plivo](https://github.com/novuhq/novu/tree/main/providers/plivo)
* [SNS](https://github.com/novuhq/novu/tree/main/providers/sns)
* [Nexmo - Vonage](https://github.com/novuhq/novu/tree/main/providers/nexmo)
* [Sms77](https://github.com/novuhq/novu/tree/main/providers/sms77)
* [Telnyx](https://github.com/novuhq/novu/tree/main/providers/telnyx)
* [Termii](https://github.com/novuhq/novu/tree/main/providers/termii)
* [Gupshup](https://github.com/novuhq/novu/tree/main/providers/gupshup)

### 📱 Push

* [FCM](https://github.com/novuhq/novu/tree/main/providers/fcm)
* [Expo](https://github.com/novuhq/novu/tree/main/providers/expo)
* [SNS](https://github.com/novuhq/novu/tree/main/providers/sns)

### 👇 Chat

* [Slack](https://github.com/novuhq/novu/tree/main/providers/slack)
* [Discord](https://github.com/novuhq/novu/tree/main/providers/discord)

### 📱 In-App

* [Novu](https://docs.novu.co/notification-center/getting-started)


# Bridge Endpoint
Source: https://v0.x-docs.novu.co/framework/concepts/endpoint



## Bridge Endpoint

Novu Framework requires a **single** `HTTP` endpoint (`/api/novu` or similar) to be exposed by your application. This endpoint is used to receive events from our Worker Engine.

You can view the Bridge Endpoint as a webhook endpoint that Novu will call when it needs to retrieve contextual information for a given subscriber and notification.

Using the `create-novu-app` command creates a Bridge application for you with a Bridge endpoint ready to go.

## The `serve` function

We offer framework specific wrappers in form of an exported `serve` function that abstracts away:

* Parsing the incoming request for `GET`, `POST`, `PUT` and `OPTIONS` requests
* HMAC header authentication
* Framework specific response and error handling

Currently, we offer `serve` functions for the following frameworks:

* [Next.js](/framework/sdk/frameworks/nextjs)
* [Express.js](/framework/sdk/frameworks/express)
* [Nuxt](/framework/sdk/frameworks/nuxt)
* [h3](/framework/sdk/frameworks/h3)
* [Remix](/framework/sdk/frameworks/remix)
* [Sveltekit](/framework/sdk/frameworks/sveltekit)

## Writing a custom `serve` function

If we currently don't support your framework, you can write a custom `serve` function like the following example:

```ts theme={null}
import { type Request, type Response } from 'express';
import { NovuRequestHandler, ServeHandlerOptions } from '@novu/framework';

export const serve = (options: ServeHandlerOptions): any => {
  const requestHandler = new NovuRequestHandler({
    frameworkName: 'express',
    ...options,
    handler: (
      incomingRequest: Request,
      response: Response,
    ) => ({
        method: () => incomingRequest.method,
        headers: (key) => {
            const header = incomingRequest.headers[key];
            return Array.isArray(header) ? header[0] : header;
        },
        queryString: (key) => {
                const qs = incomingRequest.query[key];
                return Array.isArray(qs) ? qs[0] : qs;
        },
        body: () => incomingRequest.body,
        url: () => new URL(incomingRequest.url, `https://${incomingRequest.headers.get("host") || ""}`),
        transformResponse: ({ body, headers, status }) => {
            Object.entries(headers).forEach(([headerName, headerValue]) => {
              response.setHeader(headerName, headerValue);
            });

            return response.status(status).send(body);
       },
    }),
  });

  return requestHandler.createHandler();
};
```


# Step Inputs
Source: https://v0.x-docs.novu.co/framework/concepts/inputs



Inputs are defined using [JSON Schema](/framework/recipes/json-schema), providing a strong run-time validation system for your workflows.

This ensures that you as the developer, and your non-technical peers are speaking the same language.
Those responsible for styling and copy can edit with confidence, knowing their changes are tested in code.

## Inputs vs Payload

**Inputs** - For Non-Technical Peers and Developers. Managed in the Novu Web UI, defined by developers and used by non-technical peers.

<Info>
  **Examples** - Color of a button, text of a button, should a section be shown, digest duration, static text content, the order of the email sections, and etc...
</Info>

**Payload Schema** - For Developers. Passed during the `novu.trigger` method, and controlled by the developer.

<Info>
  **Examples** - User ID, Post ID, Comment, Order ID, 2FA token and etc...
</Info>

## Step Inputs

[Step](/framework/concepts/steps) input schema is defining the input passed during the `step` method. Those inputs can be modified and persisted in the Novu Web UI.

The snippet below shows configuration for the Workflow payload schema and the Step input schema. If you don’t provide a schema, Typescript will infer the data type to `unknown`, reminding you of the best practice to specify your schema.

```tsx theme={null}
workflow('new-signup', async ({ step, payload }) => {
    await step.email(
      'send-email',
      async (inputs) => {
          return {
            subject: inputs.subjectTitle,
            body: render(<ReactEmailContent hideBanner={inputs.hideBanner} components={inputs.components} />),
        }
      }, {
	      // Learn about JSON Schema here: https://json-schema.org/specification
        inputSchema: {
	        // Always `object`
          type: 'object',
          // Specify the properties to validate. Supports deep nesting.
          properties: {
            hideBanner: { type: 'boolean', default: false },
            subjectTitle: { type: 'string' },
            // Allowing no code control over the component in the Web UI
            components: {
                type: "array",
                items: {
                    type: "string"
                },
                default: ["header", "cta-row", "footer"]
            }
          },
          // Specify the array of which properties are required.
          required: ['complianceFooter'],
          // Used to enforce full type strictness, with no rogue properties.
          additionalProperties: false,
		      // The `as const` is important to let Typescript know that this
		      // type won't change, enabling strong typing on `inputs` via type
		      // inference of the provided JSON Schema.
        } as const,
      });
});
```

Learn more about [JSON Schema here](https://json-schema.org/specification), including the powerful validation features to ensure your Content renders perfectly, every time.

<Note>
  Other validators, including Zod and more, coming soon.
  Any validator that supports transformation to JSON Schema can be added.
</Note>

## JSON Schema Examples

To Learn more about advanced examples, visit our [JSON Schema](/framework/recipes/json-schema) page.


# Payload
Source: https://v0.x-docs.novu.co/framework/concepts/payload



Workflow payload is the data passed during the `novu.trigger` method. This is useful for ensuring that the payload is correctly formatted and that the data is valid.

## Payload Schema

Payload schema is defining the payload passed during the `novu.trigger` method. This is useful for ensuring that the payload is correctly formatted and that the data is valid.

```tsx theme={null}
workflow('comment-on-post', async ({ step, payload }) => {
    await step.email(
      'send-email',
      async () => {
          return {
            subject: `You have a new comment from: ${payload.author_name}.`,
            body: render(<ReactEmailContent comment={payload.comment} />),
        }
      });
  },
  {
    payloadSchema: {
            // Always `object`
          type: 'object',
          // Specify the properties to validate. Supports deep nesting.
          properties: {
            post_id: { type: 'number' },
            author_name: { type: 'string' },
            comment: { type: 'string', maxLength: 200 },
          },
          // Specify the array of which properties are required.
          required: ['post_id', 'comment'],
          // Used to enforce full type strictness, with no rogue properties.
          additionalProperties: false,
		      // The `as const` is important to let Typescript know that this
		      // type won't change, enabling strong typing on `inputs` via type
		      // inference of the provided JSON Schema.
        } as const,
  },
);
```

## Passing Payload

Here is an example of the validated payload during trigger:

```tsx theme={null}
novu.trigger('comment-on-post', {
    to: 'subscriber_id',
    payload: {
        post_id: 1234,
        author_name: 'John Doe',
        comment: 'Looks good!'
    }
});
```


# Dev Studio
Source: https://v0.x-docs.novu.co/framework/concepts/studio



The Echo Dev Studio is a companion app to the Echo Client SDK. Its goal is to provide a local environment that lives near your code.

To launch the dev studio locally you can run: `npx novu-labs@latest echo` . The Dev Studio will be started by default on port 2022, and accessible via: `http://localhost:2022`

After successfully connecting the Studio to your local edge endpoint, you will be able to preview in real time any workflows and content defined in your code. This is ideal for quick prototyping, debugging, styling, and adjusting your workflows before syncing them to Novu Cloud.

### Inputs and Payload forms

You can quickly modify the step inputs and workflow payload to preview your workflow's different states and be generated with. This is helpful to quickly debug how the email will behave in case of a missing input, or iterate more complex content structures.

### Syncing State

Sync state to your Production or Development environment in Novu, is recommended to do via your CI pipeline. However, a sync can be made using the Dev Studio for quick experimentation.

Click on the `Sync` button at the top right corner of the navigation bar, and a Diff will be generated between your local and the Novu Cloud environments.

After inspecting the State Diff, and specifying the remote `Echo Url` Click on the `Deploy Changes` button.

### **Debugging locally**

To allow Novu to communicate with your local machine a tunnel will need to be generated. The quickest way to do it is with `localtunnel.` To Create a new tunnel in your terminal, type: `npx localtunnel --port <YOUR_EDGE_PORT>` . This command will return an https endpoint, which then can be used during the sync state flow described earlier.


# Workflows
Source: https://v0.x-docs.novu.co/framework/concepts/workflows

Workflows are at the core of responding to events in your system with notifications. Novu Framework enables you to declare type-safe, validated, and version-controlled Novu Workflows with code.

## Introduction

The most basic Workflow to send a notification in response to an event looks like:

```tsx theme={null}
import { workflow } from '@novu/framework';

const myWorkflow = workflow('new-signup', async ({ step, payload }) => {
	// Send a welcome email
  await step.email('send-email', async () => {
    return {
      subject: `Welcome to Acme, ${payload.name}`,
      body: 'We look forward to helping you achieve mission.',
    }
  });
  // JSON Schema for validation and type-safety. Zod, and others coming soon.
}, { payloadSchema: { properties: { name: { type: 'string' }}}} );
```

## Just-in-time data fetching

You can add any custom logic into your steps that you need. Maybe you’d like to fetch some information about your new sign-up from somewhere else during the Workflow execution. You can achieve it with the following changes:

```tsx theme={null}
const myWorkflow = workflow('new-signup', async ({ step, payload }) => {
	// Send a welcome email
  await step.email('send-email', async () => {
	  // Fetch the user from your database
	  const user = await db.getUser(payload.userId);
        return {
          subject: `Welcome to Acme ${user.productTier} tier, ${user.name}.`,
          // 'Welcome to Acme Business tier, John Doe.'
          body: 'We look forward to helping you achieve mission.',
        }
      });
      // Changing the schema from `name` -> `userId`, for type-safety.
    }, { payloadSchema: { properties: { userId: { type: 'string' }}}} );
```

We call this **just-in-time** notification data fetching. It allows you pull in data from the relevant sources during the Workflow execution, removing the need to store all of your subscriber data in Novu.

## Multi-step workflow

Now, what if you wanted to send another update to the same new user in 1 week? But, you don't want to send the follow-up if the User opted out. We can add more steps to the Workflow to achieve this.

```tsx theme={null}
const myWorkflow = workflow(
  'new-signup',
  async ({ step, payload }) => {
    await step.email('send-email', async () => {
      const user = await db.getUser(payload.userId);
      return {
        subject: `Welcome to Acme ${user.productTier} tier, ${user.name}.`,
        body: 'We look forward to helping you achieve mission.',
      };
    });

    // Wait for 1 week before continuing. After 1 week, Novu will continue
    // executing the Workflow from here.
    await step.delay('onboarding-follow-up', async () => ({
      amount: 1,
      type: 'regular',
      unit: 'weeks',
    }));

    // 1 week passed, let's follow up with an in-app notification.
    await step.inApp(
      'onboarding-follow-up',
      async (inputs) => {
        const user = await db.getUser(payload.userId);
        // The `feedbackUrl` can be updated in Novu Web without changing code.
        // This helps you to create re-usable Workflow snippets.
        return {
          body: `Hey ${user.name}! How do you like the product?

      Let us know <a href="${inputs.feedbackUrl}">here</a>
      if you have any questions.`,
        };
      },
      {
        // Don't follow up if the Subscriber opted out.
        skip: () => !payload.shouldFollowUp,
        // Add validation to ensure `feedbackUrl` provided in Web is a `uri`
        inputSchema: {
          type: 'object',
          properties: { feedbackUrl: { type: 'string', format: 'uri', default: 'https://acme.com/feedback' } },
          required: ['feedbackUrl'],
          additionalProperties: false,
        } as const,
      },
    );
  },
  {
    payloadSchema: {
      type: 'object',
      properties: {
        userId: { type: 'string' },
        shouldFollowUp: { type: 'boolean', default: true },
      },
      required: ['userId', 'shouldFollowUp'],
      additionalProperties: false,
    } as const,
  },
);
```

With this simple Workflow, we:

* Sent a new signup email
* Waited 1 week
* Sent an in-app follow-up notification

You should now have a grasp of the flexibility that Novu Framework offers.

Continue your reading in [Steps](/framework/concepts/steps) to find out the other channels and actions you can use with Novu Framework.

## Workflow Interface

```tsx theme={null}
workflow(
	// the Workflow name. Must be unique across your Bridge server.
	'new-signup',
	// Workflow resolver, the entry-point for your Workflow steps
	async ({
		// Helper function to declare your Workflow Steps.
		step,
		// Workflow Trigger payload
		payload,
	}) => {
	// ...your Workflow Steps

}, {
	// JSON Schema for validation and type-safety. Zod, and others coming soon.
	// https://json-schema.org/draft-07/json-schema-release-notes

	// The schema for the Workflow payload passed dynamically via Novu Trigger API
	// Defaults to an empty schema.
	payloadSchema: { properties: { name: { type: 'string' }}},
	// The schema for the Workflow inputs passed statically via Novu Web
	// Defaults to an empty schema.
	inputSchema: { properties: { brandColor: { type: 'string' }}},
});
```


# GitHub Actions
Source: https://v0.x-docs.novu.co/framework/deployment/actions



You can also deploy the workflow state with our built-in GitHub Action command:

```yaml theme={null}
name: Deploy Workflow State to Novu

on:
  push:
    branches:
      - main
jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2
		  - name: Sync State to Novu
		    uses: novuhq/actions-novu-sync@v0.0.4
		    with:
		      novu-api-key: ${{secrets.NOVU_API_KEY}} # Your Dev or Prod API Key to Novu
		      bridge-url: "" # This will be your target environment bridge url
```


# CLI
Source: https://v0.x-docs.novu.co/framework/deployment/cli



The Echo CLI provides a mechanism for you to synchronize your Workflows into Novu Cloud so that non-technical Novu Users can control the Workflow and Step-level inputs and enable your Workflows to be triggered via Novu API.

```bash theme={null}
npx novu-labs@latest sync --echo-url <YOUR URL> --api-key <NOVU_API_KEY>
```


# Going to Production
Source: https://v0.x-docs.novu.co/framework/deployment/production



Novu operates in a multi environment setup. Currently Novu Supports 2 environments:

* **Development** - This is the environment where the development team works on workflows.
* **Production** - This is the environment that is used to trigger workflows to your customers.

## Pushing changes to Cloud

Novu Framework operates in a GitOps model. This means that the source of truth for your workflows and configurations are located in your Git as Code.

The general workflow for pushing changes to Cloud is as follows:

* Create a feature branch
* Develop workflows locally in your Bridge application
* Sync changes to the Development environment to test e2e
* Merge the feature branch to your `dev` branch
  * This will trigger a CI/CD pipeline that will deploy the changes to the Development environment
* Test the changes in the Development environment
* Merge the `dev` branch to the `main` branch
  * This will trigger a CI/CD pipeline that will deploy the changes to the Production environment

## Networking

Novu Cloud workers will need to be able to communicated with your Bridge Endpoint. You will need to ensure that your firewall rules allow traffic from the internet.
Due to the autoscaling nature of Novu Cloud, we don't have a set of IP Addresses that you can whitelist.

## Security

Novu Cloud workers are GDPR, SOC2 type II and ISO 27001 compliant. We take security very seriously and have implemented a number of security measures to ensure that your data is safe.
Novu Framework has a builtin security mechanism that ensures that the requests are authentic from Novu Cloud using an HMAC signature.

HMAC Verification is turned on by default

```typescript theme={null}
export const client = new Client({
  apiKey: process.env.NOVU_API_KEY,,
  strictAuthentication: process.env.NODE_ENV !== "development", // set to true by default
});
```

<Info>
  For local development with Studio `strictAuthentication` should be set to `false`.
</Info>

The `X-Novu-Signature` header included in each signed event contains a timestamp and one or more signatures that we verify.
The timestamp is prefixed by t=, and each signature is prefixed by a scheme.
Schemes start with v, followed by an integer. Currently, the only valid live signature scheme is v1.

Handling the signature verification is done by the Novu Framework, you don't need to perform any action.

## CI/CD Integrations

Novu currently supports the following CI integrations:

* **GitHub Actions** - [Direct Integration](/framework/deployment/actions)
* **GitLab CI** - Using our [CLI command](/framework/deployment/cli)
* **Jenkins** - Using our [CLI command](/framework/deployment/cli)
* **CircleCI** - Using our [CLI command](/framework/deployment/cli)
* **Bitbucket Pipelines** - Using our [CLI command](/framework/deployment/cli)
* **Azure DevOps** - Using our [CLI command](/framework/deployment/cli)
* **Travis CI** - Using our [CLI command](/framework/deployment/cli)
* **Other** - For any other CI/CD tool, you can use our [CLI command](/framework/deployment/cli)

<Info>
  Direct integration with other CI/CD tools is on our roadmap. If you would like to see a specific CI/CD tool integrated, please reach out to us.
</Info>


# React E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/react-email



Integrating Novu Framework with [React.Email](https://react.email/) for your Next.js application can be done in three steps. If you don't have an app, you can create one with the `create-novu-app` command.

<Steps>
  <Step title="Install React.Email components">
    Install the required React.Email components.

    ```bash theme={null}
      npm i @react-email/components react-email
    ```
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.tsx` file for your email template.

    ```tsx theme={null}
    import * as React from "react";
    import { Button, Html } from "@react-email/components";

    function Email(props) {
      return (
        <Html>
          <Button
            href="https://example.com"
            style={{ background: "#000", color: "#fff", padding: "12px 20px" }}
          >
            Click me
          </Button>
        </Html>
      );
    }

    export function renderEmail(inputs) {
      return render(<Email {...inputs} />);
    }
    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```tsx theme={null}
    import { renderEmail } from './sample-email.tsx';
    import { workflow } from '@novu/framework';

    workflow('new-signup', async ({ step, payload }) => {
      await step.email('send-email', async (inputs) => {
        return {
          subject: `Welcome to React E-mail`,
          body: renderEmail(inputs),
        }
      });
    });
    ```
  </Step>
</Steps>


# Remix w/ React E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/remix-react-email



Integrating Novu Framework with [React email](https://react.email/) for your Remix application can be done in three steps. If you don't have an app, you can [clone our Remix example](https://github.com/novuhq/novu-framework-remix-example).

<Steps>
  <Step title="Install React email components">
    Install the required React email components.

    ```bash theme={null}
      npm i @react-email/components react-email
    ```
  </Step>

  <Step title="Create email templates folder">
    Create an `emails` folder in the `app` directory of your Remix app.
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.tsx` file for your email template.

    ```ts theme={null}
    import { Button, Html } from "@react-email/components";

    function Email(props) {
      return (
        <Html>
          <Button
            href="https://example.com"
            style={{ background: "#000", color: "#fff", padding: "12px 20px" }}
          >
            Click me
          </Button>
        </Html>
      );
    }

    export function renderEmail(inputs) {
      return render(<Email {...inputs} />);
    }
    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```tsx theme={null}
    import { renderEmail } from './sample-email.tsx';
    import { workflow } from '@novu/framework';

    workflow('new-signup', async ({ step, payload }) => {
      await step.email('send-email', async (inputs) => {
        return {
          subject: `Welcome to Remix and React E-mail`,
          body: renderEmail(inputs),
        }
      });
    });
    ```
  </Step>
</Steps>


# Svelte E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/svelte-email



Integrating Novu Framework with [Svelte email](https://react.email/) for your Svelte application can be done in three steps. If you don't have an app, you can [clone our Svelte example](https://github.com/novuhq/novu-svelte-email).

<Steps>
  <Step title="Install Svelte email components">
    Install the required Svelte email components.

    ```bash theme={null}
      npm i svelte-email
    ```
  </Step>

  <Step title="Create email templates folder">
    Create an `emails` folder in the `src/lib` directory of your Svelte app.
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.svelte` file for your email template.

    ```ts theme={null}
    <script lang="ts">
        import { Button, Container, Head, Hr, Html, Img, Preview, Section, Text } from 'svelte-email';

        export let firstName = 'John';

        const fontFamily =
            '-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen-Sans,Ubuntu,Cantarell,"Helvetica Neue",sans-serif';

        const main = {
            backgroundColor: '#ffffff'
        };

        const container = {
            margin: '0 auto',
            padding: '20px 0 48px'
        };

        const logo = {
            margin: '0 auto'
        };

        const paragraph = {
            fontFamily,
            fontSize: '16px',
            lineHeight: '26px'
        };

        const btnContainer = {
            textAlign: 'center' as const
        };

        const button = {
            fontFamily,
            backgroundColor: '#5F51E8',
            borderRadius: '3px',
            color: '#fff',
            fontSize: '16px',
            textDecoration: 'none',
            textAlign: 'center' as const,
            display: 'block'
        };

        const hr = {
            borderColor: '#cccccc',
            margin: '20px 0'
        };

        const footer = {
            fontFamily,
            color: '#8898aa',
            fontSize: '12px'
        };
    </script>

    <Html lang="en">
        <Head />
        <Preview preview="Welcome to svelte-email" />
        <Section style={main}>
            <Container style={container}>
                <Img
                    src="https://svelte.dev/svelte-logo-horizontal.svg"
                    alt="Svelte logo"
                    style={logo}
                    width="200"
                    height="50"
                />
                <Text style={paragraph}>{firstName}, welcome to svelte-email</Text>
                <Text style={paragraph}>A Svelte component library for building responsive emails</Text>
                <Section style={btnContainer}>
                    <Button pX={12} pY={12} style={button} href="https://github.com/carstenlebek/svelte-email">
                        View on GitHub
                    </Button>
                </Section>
                <Text style={paragraph}>Happy coding!</Text>
                <Hr style={hr} />
                <Text style={footer}>Carsten Lebek</Text>
            </Container>
        </Section>
    </Html>
    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```tsx theme={null}
    import WelcomeEmail from '$lib/emails/sample-email.svelte';
    import { render } from 'svelte-email';
    import { workflow } from '@novu/framework';

    workflow('new-signup', async ({ step, payload }) => {
        await step.email(
            'send-email',
            async (inputs) => {
                const html = render({
                    template: WelcomeEmail,
                    props: {
                        firstName: 'John',
                    },
                });
                return {
                    subject: `Welcome to Svelte E-mail`,
                    body: html,
                }
            });
        }
    );
    ```
  </Step>
</Steps>


# Vue E-mail
Source: https://v0.x-docs.novu.co/framework/integrations/vue-email



You can integrate Novu Framework with [Vue Email](https://vuemail.net/) in a few simple steps. This guide will walk you through the process of creating a new email template using Vue Email and Nuxt.

For a Quickstart Boilerplate project using Nuxt.js, and Vue Email, check out the [Vue Email Starter repository](https://github.com/novuhq/novu-framework-nuxt-example/)

## Quickstart

<Steps>
  <Step title="Install Vue.Email components">
    Install the required Vue.Email components.

    ```bash theme={null}
    npm install vue-email @vue-email/compiler @vue-email/nuxt
    ```
  </Step>

  <Step title="Create templates folder">
    Create a `templates` folder in the root of your Nuxt app
  </Step>

  <Step title="Update nuxt.config.ts File">
    Update your `nuxt.config.ts` file to include the Vue Email module.

    ```ts nuxt.config.ts theme={null}
    export default defineNuxtConfig({
        devtools: { enabled: true },
        components: true,

        modules: [
            '@vue-email/nuxt',
        ],
    })
    ```
  </Step>

  <Step title="Write your email">
    Create a new `sample-email.vue` file in the `templates` folder for your email template.

    ```vue theme={null}
    <script setup lang="ts">
        import { defineProps, withDefaults } from 'vue'

        interface Props {

        }

        const baseUrl = "https://react-email-demo-bdj5iju9r-resend.vercel.app";

        const props = withDefaults(defineProps<Props>(), {});
    </script>

    <template>
        <ETailwind>
            <EHtml>
                <EHead/>
                <EPreview>Email Preview Text</EPreview>
                <EBody class="bg-white my-auto mx-auto font-sans">
                    <EContainer class="border border-solid border-[#eaeaea] p-[20px] md:p-7 rounded my-[40px] mx-auto max-w-[465px]">
                        <EHeading class="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
                            Hello World!
                        </EHeading>
                    </EContainer>
                </EBody>
            </EHtml>
        </ETailwind>
    </template>

    ```
  </Step>

  <Step title="Write your workflow">
    Define your Workflow using the above template

    ```ts theme={null}
    import { config } from '@vue-email/compiler';
    import { workflow } from '@novu/framework';

    const vueEmail = config('templates', {
        verbose: false,
        options: {},
    });


    workflow('new-signup', async ({step, payload}) => {
        await step.email('send-email', async (inputs) => {
            const template = await vueEmail.render('sample-email.vue', {
                props: inputs
            })

            return {
                subject: `Welcome to Vue E-mail`,
                body: template.html
            }
        });
    });
    ```
  </Step>
</Steps>

## Learn More

To learn more, refer to [Vue Email documentation](https://vuemail.net/).


# No-Code Tools to control your Notification Flows
Source: https://v0.x-docs.novu.co/framework/non-developers/introduction

Change notification content and behavior with confidence using Novu Web UI.

Novu Framework was designed to bridge the gap between developers and on-developers in the team.

* **Developers** - Define and abstract away complex logic, data manipulation and hydration, html and etc...
* **Non-Developers** - Use the Novu Web UI to control the content and behavior of the notifications using [Inputs](/framework/concepts/inputs).

## How to Modify Inputs?

Inputs are modified directly on the [Novu Web UI](https://web.novu.co). Each Workflow editor page have an 'Inputs' tab where you can modify them.
When Saving the changes, the new Input values will be used in the notification sent to your subscriber.

## Common Input Usecases

### Change Notification Content

An input can be as broad as `content` or as specific as `2fa_code_title_color`. This allows you to change the content of the notification without needing to touch the code.

<Tip>
  Currently you cannot use Dynamic payload variables as part of the Input. Reach out to us if you need this capability.
</Tip>

### Change Digest or Delay Frequency

Inputs can be used for controlling any aspect of the step configuration, for example:

* Digest Length
* Delay Amount
* Digest Type (Daily, Weekly, Monthly)
* etc...

### Control structure and layout

Inputs can be used to show/hide or rearrange the layout of the notification.
For example, you can have an input to show/hide a button, or change the position of a specific email section.


# Quick Start
Source: https://v0.x-docs.novu.co/framework/quickstart

Novu Framework, the Code-first notification workflow engine. Build advanced workflows while giving your non-technical teammates complete control over content and behavior.

<Note>
  **Novu Framework is currently in public Alpha.** Need help? Have a suggestion? Join our [Discord community](https://discord.gg/novu).
</Note>

## Introduction to Novu Framework

Novu Framework allows you to write notification workflows in your codebase. Workflows are functions that execute business logic and use your preferred libraries for email, SMS, and chat generation. You can use Novu Framework with [React.Email](https://react.email/), [MJML](https://mjml.io/), or any other template generator.

<EchoTerminal />

## Try it now

To create a new Bridge application that will allow you to define your workflow in code, open your terminal and execute the `create-novu-app` command.

```shell theme={null}
npx create-novu-app@latest --api-key=<API_KEY_HERE>
```

The command will ask you if you wish to install from a React.Email template or a clean project.

## Core features

<CardGroup>
  <Card title="Bring Your Own Code" icon="code">
    Write the notification workflows as functions in your codebase,  version, and manage them using Git.
  </Card>

  <Card title="Limitless Integrations" icon="plug" href={'/framework/integrations'}>
    Use React.email, MJML, or fetch templates from Braze, Hubspot, Sendgrid, and more...
  </Card>

  <Card title="Type Safety" icon="shield">
    Bring your own schemas for full, end-to-end validation and type safety.
  </Card>

  <Card title="Cloud Synchronization" icon="cloud">
    Sync your workflows with Novu Cloud and ease collaboration.
  </Card>
</CardGroup>

## How it Works?

Novu Framework introduces a new paradigm when working with Novu. Rather than defining workflows and templates at Novu Cloud, Novu Framework enables you to work in your application, use your own libraries and connect to your production environment during workflow execution over HTTPS.

The Novu Framework exports the client you use to define and serve your workflows and their steps over HTTPS. The workflows can be added to your preferred framework. During workflow execution Novu Cloud makes HTTPS requests to your Bridge server for *just-in-time* Content and Subscribers resolution.

<Frame>
  <img />
</Frame>

## For Non-Technical Users

Novu Framework was built with non-technical user in mind. Engineers can write complex workflows and expose a type-safe [Inputs](/framework/concepts/inputs) interface powered by JSON-Schema.
This enables Non-Technical teammates to safely modify the workflow without breaking mission critical notifications.


# JSON Schema
Source: https://v0.x-docs.novu.co/framework/recipes/json-schema



JSON Schema can be used to define the [Workflow Payload](/framework/concepts/inputs) and [Step Inputs](/framework/concepts/inputs).
It provides a strongly-typed way to define the structure of the data that is expected by the Workflow or Step.
And also as a contract for changing the Workflow behaviour using the Platform User Interface.

Learn more about JSON Schema at [json-schema.org](https://json-schema.org/).

## Examples

### Simple

```json theme={null}
{
  "type": "object",
  "required": [
    "firstName",
    "lastName"
  ],
  "properties": {
    "firstName": {
      "type": "string",
      "title": "First name",
      "default": "Chuck"
    },
    "lastName": {
      "type": "string",
      "title": "Last name"
    },
    "age": {
      "type": "integer",
      "title": "Age"
    }
  }
}
```

### Nested Array Structure

```json theme={null}
{
  "type": "object",
  "required": [
    "title"
  ],
  "properties": {
    "title": {
      "type": "string",
      "title": "Task list title"
    },
    "tasks": {
      "type": "array",
      "title": "Tasks",
      "items": {
        "type": "object",
        "required": [
          "title"
        ],
        "properties": {
          "title": {
            "type": "string",
            "title": "Title",
            "description": "A sample title"
          },
          "details": {
            "type": "string",
            "title": "Task details",
            "description": "Enter the task details"
          },
          "done": {
            "type": "boolean",
            "title": "Done?",
            "default": false
          }
        }
      }
    }
  }
}
```

### Reference and Reuse Blocks

```json theme={null}
{
  "definitions": {
    "address": {
      "type": "object",
      "properties": {
        "street_address": {
          "type": "string"
        },
        "city": {
          "type": "string"
        },
        "state": {
          "type": "string"
        }
      },
      "required": [
        "street_address",
        "city",
        "state"
      ]
    },
    "node": {
      "type": "object",
      "properties": {
        "name": {
          "type": "string"
        },
        "children": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/node"
          }
        }
      }
    }
  },
  "type": "object",
  "properties": {
    "billing_address": {
      "title": "Billing address",
      "$ref": "#/definitions/address"
    },
    "shipping_address": {
      "title": "Shipping address",
      "$ref": "#/definitions/address"
    },
    "tree": {
      "title": "Recursive references",
      "$ref": "#/definitions/node"
    }
  }
}
```

### Any Of Schemas

```json theme={null}
{
  "type": "object",
  "properties": {
    "age": {
      "type": "integer",
      "title": "Age"
    },
    "items": {
      "type": "array",
      "items": {
        "type": "object",
        "anyOf": [
          {
            "properties": {
              "foo": {
                "type": "string"
              }
            }
          },
          {
            "properties": {
              "bar": {
                "type": "string"
              }
            }
          }
        ]
      }
    }
  },
  "anyOf": [
    {
      "title": "First method of identification",
      "properties": {
        "firstName": {
          "type": "string",
          "title": "First name",
          "default": "Chuck"
        },
        "lastName": {
          "type": "string",
          "title": "Last name"
        }
      }
    },
    {
      "title": "Second method of identification",
      "properties": {
        "idCode": {
          "type": "string",
          "title": "ID code"
        }
      }
    }
  ]
}
```

### One Of Schema

```json theme={null}
{
  "type": "object",
  "oneOf": [
    {
      "properties": {
        "lorem": {
          "type": "string"
        }
      },
      "required": [
        "lorem"
      ]
    },
    {
      "properties": {
        "ipsum": {
          "type": "string"
        }
      },
      "required": [
        "ipsum"
      ]
    }
  ]
}
```

### If Then Else

```json theme={null}
{
  "type": "object",
  "properties": {
    "animal": {
      "enum": [
        "Cat",
        "Fish"
      ]
    }
  },
  "allOf": [
    {
      "if": {
        "properties": {
          "animal": {
            "const": "Cat"
          }
        }
      },
      "then": {
        "properties": {
          "food": {
            "type": "string",
            "enum": [
              "meat",
              "grass",
              "fish"
            ]
          }
        },
        "required": [
          "food"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "animal": {
            "const": "Fish"
          }
        }
      },
      "then": {
        "properties": {
          "food": {
            "type": "string",
            "enum": [
              "insect",
              "worms"
            ]
          },
          "water": {
            "type": "string",
            "enum": [
              "lake",
              "sea"
            ]
          }
        },
        "required": [
          "food",
          "water"
        ]
      }
    },
    {
      "required": [
        "animal"
      ]
    }
  ]
}
```

### Enum Objects

```json theme={null}
{
  "definitions": {
    "locations": {
      "enumNames": [
        "New York",
        "Amsterdam",
        "Hong Kong"
      ],
      "enum": [
        {
          "name": "New York",
          "lat": 40,
          "lon": 74
        },
        {
          "name": "Amsterdam",
          "lat": 52,
          "lon": 5
        },
        {
          "name": "Hong Kong",
          "lat": 22,
          "lon": 114
        }
      ]
    }
  },
  "type": "object",
  "properties": {
    "location": {
      "title": "Location",
      "$ref": "#/definitions/locations"
    },
    "locationRadio": {
      "title": "Location Radio",
      "$ref": "#/definitions/locations"
    },
    "multiSelect": {
      "title": "Locations",
      "type": "array",
      "uniqueItems": true,
      "items": {
        "$ref": "#/definitions/locations"
      }
    },
    "checkboxes": {
      "title": "Locations Checkboxes",
      "type": "array",
      "uniqueItems": true,
      "items": {
        "$ref": "#/definitions/locations"
      }
    }
  }
}
```

### Regex Validation

The following example matches a simple North American telephone number with an optional area code:

```json theme={null}
{
  "type": "object",
  "properties": {
    "phone": {
      "type": "string",
      "pattern": "^(\\([0-9]{3}\\))?[0-9]{3}-[0-9]{4}$"
    }
  }
}
```

## Other Resources

* [Examples](https://json-schema.org/learn/miscellaneous-examples)
* [React JSON Schema](https://rjsf-team.github.io/react-jsonschema-form/)
* [JSON Schema Validator](https://www.jsonschemavalidator.net/)
* [JSON Schema Lint](https://jsonschemalint.com/)


# Roadmap
Source: https://v0.x-docs.novu.co/framework/roadmap



This document outlines the roadmap for the Novu Framework project. It is a living document and will be updated as the project progresses.

Our goal with Novu Framework is to create a Code-First but Product in-mind. Here you can see parts of our roadmap and future plans for it:

Looking to add a feature request or upvote and existing feature? Head over to our [Public Roadmap](https://roadmap.novu.co).

## Novu Framework, Now and Next

* ✅ **Workflows**: the ability to create multi-step workflows and manage them using Code.
* ✅ **CLI**: a command-line interface to interact with Novu Framework.
* ✅ **Studio**: a visual front to preview your local work.
* ✅ **Step Inputs**: JSON-Schema based interface for not technical users to modify the workflow content and behaviour.
* ✅ **GitHub Actions**: sync your workflows using GitHub Actions.
* ✅ **In App Seen/Read**: the ability to see the status of the in-app message.
* ✅ **Custom Step**: the ability to create custom and execute custom code in the workflow. For example: custom provider, retrieving database information, and 3rd party service integration.
* 🔜 **Zod Schema**: the ability to define the schema for the workflow and step inputs using Zod.
* 🔜 **Define Integrations**: code-first approach of creating and managing your provider integrations
* 🔜 **Email Reply Hook**: executing a custom logic code when a user replies to the email.
* 🔜 **Webhook**: receive webhooks about the execution flow of a workflow in Novu Framework.
* 🔜 **Eslint Plugin**: follow best practices and avoid common mistakes when writing code for Novu Framework.
* 🔜 **Codegen**: use our community driven list of workflow templates to use out of the box.


# Introduction
Source: https://v0.x-docs.novu.co/framework/sdk/client



See the snippet below to learn how to configure your Bridge endpoint application.

```tsx theme={null}
import { Client } from '@novu/framework';

const client = new Client({
  /**
   * Specify a custom Novu API URL.
   * Defaults to 'https://api.novu.co', for EU use: https://eu.api.novu.co
   */
	apiUrl: 'https://api.novu.co',
  /**
   * Specify your Novu API key, to secure your Bridge API endpoint.
   * Novu communicates securely with your endpoint using a signed HMAC header,
   * ensuring that only trusted requests from Novu are actioned by your Bridge API.
   * The API key is used to sign the HMAC header.
   */
	apiKey: process.env.NOVU_API_KEY,
  /**
   * Explicitly use HMAC signature verification.
   * Setting this to `false` will enable Novu to communicate with your Bridge API
   * without requiring a valid HMAC signature.
   * This is useful for local development and testing.
   *
   * You are strongly encouraged to specify an `apiKey` and set this to `true` in production,
   * to ensure that only trusted requests from Novu are actioned by your Bridge API.
   *
   * Defaults to true.
   */
	strictAuthentication: process.env.NODE_ENV !== "development",
});
```


# Integrate Novu with Express.js
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/express



```tsx theme={null}
import { serve } from "@novu/framework/express";
import { myWorkflow } from "../novu/workflows";

app.use(express.json()); // Required for Novu POST requests
app.use(
  "/api/novu",
  serve({ workflows: [myWorkflow] })
);
```


# Integrate Novu with H3
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/h3



```tsx theme={null}
import { createApp, eventHandler, toNodeListener } from "h3";
import { serve } from "@novu/framework/h3";
import { createServer } from "node:http";
import { myWorkflow } from "./novu/workflows";

const app = createApp();
app.use(
  "/api/novu",
  eventHandler(
    serve({
      workflows: [myWorkflow],
    })
  )
);

createServer(toNodeListener(app)).listen(process.env.PORT || 3000);
```


# Integrate Novu with Next.js
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/nextjs



## App Router

<CodeGroup>
  ```ts app/api/novu/route.ts theme={null}
  import { serve } from "@novu/framework/next";
  import { myWorkflow } from "../../novu/workflows";

  export const { GET, POST, PUT, OPTIONS } = serve({ workflows: [myWorkflow] });
  ```
</CodeGroup>

## Pages Router

<CodeGroup>
  ```ts pages/api/novu.ts theme={null}
  import { serve } from "@novu/framework/next";
  import { myWorkflow } from '../../novu/workflows';

  export default serve({ workflows: [myWorkflow] });
  ```
</CodeGroup>

Check out a comprehensive [guide on sending notifications in Next.js with React email](/guides/framework-guides/framework-react-email).


# Integrate Novu with Nuxt
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/nuxt



Novu Framework works out of the box with Nuxt.js. You can use the `@novu/framework/nuxt` package to serve your Bridge endpoint in your Nuxt.js application.

For a boilerplate project with Vue Email, view: [Nuxt.js Boilerplate](https://github.com/novuhq/novu-framework-nuxt-example/)

<CodeGroup>
  ```ts API Routes theme={null}
  import { serve } from "@novu/framework/nuxt";
  import { myWorkflow } from "../workflows";

  export default defineEventHandler(serve({ workflows: [myWorkflow] }));
  ```
</CodeGroup>

Check out a comprehensive [guide on sending notifications in Nuxt with Vuemail](/guides/framework-guides/framework-nuxt-vuemail).


# Integrate Novu with Remix
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/remix



```tsx theme={null}
import { serve } from "@novu/framework/remix";
import { myWorkflow } from "../novu/workflows";

const handler = serve({
    workflows: [myWorkflow],
  });
  
export { handler as action, handler as loader };
```

Check out a comprehensive [guide on sending notifications in Remix with React email](/guides/framework-guides/framework-remix).


# Integrate Novu with SvelteKit
Source: https://v0.x-docs.novu.co/framework/sdk/frameworks/sveltekit



```tsx theme={null}
import { myWorkflow } from '../workflows';
import { serve } from '@novu/framework/sveltekit';

export const { GET, POST, PUT } = serve({ workflows: [myWorkflow] });
```

Check out a comprehensive [guide on sending notifications in Svelte with Svelte-email](/guides/framework-guides/framework-svelte).


# Typescript
Source: https://v0.x-docs.novu.co/framework/sdk/typescript



Novu Framework was built and optimized for extreme focus on Developer Experience.
Our `@novu/framework` SDK is written in Typescript, and we recommend using Typescript for your own projects as well.

<EchoTerminal />

## Type Safe Workflow Payloads

When defining a [workflow payload](/framework/concepts/payload) schema, our SDK will automatically infer it to a Typescript interface.

```typescript theme={null}
import { workflow } from '@novu/framework';

const myWorkflow = workflow('new-signup', async ({ step, payload }) => {
	await step.email('send-email', () => {
        return {
            subject: 'Hello World',
            // The payload object here is type-safe
            body: `Hi ${payload.name}, welcome to our platform!`
        }
	});
}, {
	// JSON Schema for validation and type-safety. Zod, and others coming soon.
	// https://json-schema.org/draft-07/json-schema-release-notes
	payloadSchema: { properties: { name: { type: 'string' }}},
});
```

## Type Safe Steps

Similarly, when defining a [step](/framework/concepts/steps) schema, our SDK will automatically infer it to a Typescript interface.


# Chat Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/chat



Use the chat channel step to send a message for providers like: Slack, WhatsApp, Discord and others.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
});
```

## Provider Overrides

Some providers offer a rich DSL for styling the messages. Novu Framework offers a robust API to leverage the provider specific capabilities using the step `providers` option object.

Let's see an example of how to send a message to Slack using the `providers` option objet.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
}, {
    providers: {
        slack: ({ inputs }) => ({
            text: 'A new post has been created',
            blocks: [
                {
                    type: 'section',
                    text: {
                        type: 'mrkdwn',
                        text: 'A new post has been created',
                    },
                },
            ],
        }),
    }
});
```

Default chat `body` field is still specified as a fallback value in case a provider specific configuration is not used.

<Info>
  Currently we only support `Slack` provider overrides. We are working on adding more providers.
</Info>


# Custom Action Step
Source: https://v0.x-docs.novu.co/framework/steps/custom

Used to execute any custom code as a step in the workflow.

A custom steps allows to execute any custom logic and persist in the durable execution context. The result of this step can be used in subsequent steps.

## Common usecases

* Making an API call to 3rd party service
* Fetch data from a database to be used in subsequent steps
* Execute a custom logic to transform data
* Custom provider implementation

## Custom Step Interface

```tsx theme={null}
const stepResult = await step.custom('custom-step', async () => {
  return {
    item_name: 'A product name',
    item_price: 100,
  };
}, {
    outputSchema: {
        type: 'object',
        properties: {
            item_name: { type: 'string' },
            item_price: { type: 'number' },
        },
        required: ['item_name', 'item_price'],
    }
});
```

### Output Schema Definition

This JSON Schema definition is used to validate the output of the custom step. If the output does not match the schema, the workflow will fail.
Novu Framework will infer the Typescript interface from the JSON Schema definition.

### Return Value

The Custom Step function should return a valid serializable object. The return value will be persisted in the durable execution context.

## Using the Custom Step Result

The result can only be used in the `resolver` of the step/providers/skip functions of subsequent steps.

```typescript theme={null}
workflow('hello-world-workflow', async ({ payload }) => {
    const task = await step.custom('fetch-db-data', async () => {
        const taskData = db.fetchTask(payload.task_id);
        return {
            task_id: taskData.id,
            task_title: taskData.title,
            complete: taskData.complete,
        };
    }, {
        outputSchema: {
            type: 'object',
            properties: {
                task_title: { type: 'string' },
                task_id: { type: 'string' },
                complete: { type: 'boolean' },
            },
            required: ['task_id', 'complete'],
        }
    });

    await step.email('send-email', () => {
        return {
            subject: `Task reminder for ${task.task_title}`,
            body: 'Task is not yet complete. Please complete the task.'
        }
    }, {
        // Only send the reminder E-mail if the task is not complete
        skip: () => !task.complete
    })
});



```


# Delay Action Step
Source: https://v0.x-docs.novu.co/framework/steps/delay



Use the delay action whenever you need to pause the execution of your workflow for a period of time.

```tsx theme={null}
await step.delay('delay-1-week', async () => {
  return {
	  unit: 'weeks', // 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
	  amount: 1, // the number of units to delay workflow execution for
	};
});
```


# Digest Action Step
Source: https://v0.x-docs.novu.co/framework/steps/digest



The digest engine is designed to streamline notifications by accumulating multiple trigger events into one coherent message before delivery to the subscriber.

This function proves beneficial when a user needs to be alerted about numerous triggers, but it's important to minimize the frequency of notifications. Novu automates this process, batching incoming trigger events according to a unique subscriberId. There is also the option to include a digestKey, providing additional control over event digestion workflows.

## Step Interface

```tsx theme={null}
const digestResult = await step.digest('digest-3-days', async () => {
  return {
	  unit: 'days', // 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
	  amount: 3, // the number of units to digest events for
	};
});
```

## Using the digested triggers

The digest function returns an array of triggers that have been digested.
You can use this array to perform any necessary actions on the digested triggers. Like Sending and email, or updating a database.

```tsx theme={null}
const digestResult = await step.digest('digest-3-days', async () => {
  return {
	  unit: 'days', // 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
	  amount: 3, // the number of units to digest events for
	};
});

await step.email('send-email', async () => {
  return {
    subject: 'Digest Email',
    body: `You have ${digestResult.events.length} new events`,
 };
});
```

The digest step returns an object with `events` array. Each event in the array has the following properties:

* `id` - The `job id` of the digested event
* `time` - The time when the event was triggered
* `payload` - The original payload passed to the event


# Email Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/email



E-mail expected to be an object with the following properties:

* `subject` - The subject of the email
* `body` - The HTML body of the email

Any content generation framework like [React Email](/framework/integrations/react-email) can be used here to generate the HTML Content.

```tsx theme={null}
await step.email('send-email', async (inputs) => {
  return {
    subject: 'You received a post',
    body: `<html><body>A new post has been created</body></html>`,
  };
});
```


# In-App Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/in-app



Novu offers notification center component that can be easily embedded into your application. Read more about it [here](/notification-center/introduction).

```tsx theme={null}
await step.inApp('send-in-app', async (inputs) => {
  return {
    body: `A new post has been created`,
  };
});
```


# Workflow Steps
Source: https://v0.x-docs.novu.co/framework/steps/introduction

Steps control the execution flow of your workflow, whilst Novu provides the context of your notification delivery events back into the Workflow execution context.

## Supported Steps

Novu Supports Channel and Action steps to be used as part of the workflow execution.

### Channel Steps

* [E-mail](/framework/steps/email)
* [Chat](/framework/steps/chat)
* [SMS](/framework/steps/sms)
* [Push](/framework/steps/push)
* [In-App](/framework/steps/in-app)

### Action steps

* [Delay](/framework/steps/delay)
* [Digest](/framework/steps/digest)

## Channel Steps Interface

Channel steps are used to send notifications to your Subscribers. Each channel can optionally configure the provider to customize content, enabling you to create enhanced content aligned with the specification of the provider. For example, you might like to use Slack blocks to send your Chat message.

All channels follow the same interface:

```tsx theme={null}
await step.email('new-post', async (inputs) => {
    return {
        subject: 'You received a post',
        body: `<html><body>A new post has been created</body></html>`,
    }
}, options);
```

* `new-post` is the unique to the workflow identifier for this step. You cannot have 2 steps using the same identifier
* `resolver` function, used to return the content of the channel.
* `options` this is an optional configuration object that defines: [Input Schema](/framework/concepts/inputs), [Provider Overrides](#provider-overrides), skip and other configurations...

## Provider Overrides

Provider overrides are used to customize the content of the notification for a specific provider. For example, you might like to use Slack blocks to send your Chat message.

Those overrides are mapped directly to the provider specific SDKs, so you can use the same properties and methods that you would use in the provider SDK.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
}, {
    providers: {
        slack: ({ inputs }) => ({
            text: 'A new post has been created',
            blocks: [
                {
                    type: 'section',
                    text: {
                        type: 'mrkdwn',
                        text: 'A new post has been created',
                    },
                },
            ],
        }),
    }
});
```

<Info>
  Currently we only support `Slack` provider overrides. We are working on adding more providers.
</Info>

When overriding a provider specific behavior, Novu still requires the default content to be returned from the resolver function.
This is because the default content is used for the fallback provider, or when the provider override is not available.

## Skip Step

A step can be conditionally skipped by returning `true` from the resolver function. This is helpful when you want to use your existing user-preference system instead of Novu.
Or conditionally skip a step if it's not relevant any more for delivery.

```tsx theme={null}
await step.chat('send-chat', async () => {
  return {
    body: 'A new post has been created',
  };
}, {
    skip: () => true,
});
```


# Push Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/push



```tsx theme={null}
await step.push('send-push', async () => {
  return {
    subject: 'You received a post',
    body: 'A new post has been created',
  };
});
```


# SMS Channel Step
Source: https://v0.x-docs.novu.co/framework/steps/sms



```tsx theme={null}
await step.sms('send-sms', async () => {
  return {
    body: 'A new post has been created',
  };
});
```


# How to send PUSH notifications to iOS devices with FCM using Novu
Source: https://v0.x-docs.novu.co/guides/FCM-iOS-Novu/how-to-send-PUSH-notifications-to-iOS-devices-with-FCM-using-Novu

Learn how to integrate Firebase Cloud Messaging with Novu and send notifications to iOS

## Prerequisites

To complete this tutorial, you will need the following:

* [Apple Developer](https://developer.apple.com/) membership (to obtain the required permissions to send push notifications)
* A machine running MacOS to work on an iOS project
* [Firebase](https://firebase.google.com/) account
* [Novu](https://web.novu.co/?utm_campaign=docs-gs-guides-fcm-ios) account
* [Xcode](https://developer.apple.com/xcode/) installed on your machine

## Create an iOS app

Open Xcode and create a new project, choosing the **App** template.

Give your project a name, and select your name as the team for now, or leave it blank.

Your bundle identifier will be generated here — you will use this later when connecting to Firebase.

Select **SwiftUI** as your interface and **Swift** as your language.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Let's build and run our iOS application to see if everything works correctly.

<Frame>
  <img />
</Frame>

Go to the Firebase documentation website, go to docs here, and select Cloud Messaging.
We will follow this guide to set up cloud messaging inside the app.

You can read more about how Firebase Cloud Messaging works by reading their [official documentation](https://firebase.google.com/docs/cloud-messaging/ios/client).

<Frame>
  <img />
</Frame>

Go to iOS+ and click on the `Set up an Apple platforms client` section.

<Frame>
  <img />
</Frame>

The first thing that we need to do is add Firebase to our iOS app.
Let's create a new Firebase project inside of the console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Create a Firebase project

Select a name for your project.

<Frame>
  <img />
</Frame>

Then, add Google Analytics to the Firebase project.

<Frame>
  <img />
</Frame>

Here, you can select your Google account.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We will click on Add Firebase to your iOS app.

<Frame>
  <img />
</Frame>

We first need to add the bundle name, so go to your iOS Xcode project and copy and paste the bundle name.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Download the `.plist` file and put it in the root of your project.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

You can put it right under `info.plist` file.

<Frame>
  <img />
</Frame>

We need to add the Firebase SDK using the Swift package manager.
Copy this [https://github.com/firebase/firebase-ios-sdk](https://github.com/firebase/firebase-ios-sdk) URL and then go to 'File`->`Add Package Dependencies...\`.
Paste that URL in the top right.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We must add the initialization code to the `AppDelegates.swift` file.

Let's import the "FirebaseCore" dependency by adding `import FirebaseCore` to the beginning of the file.

Then, we will copy `firebaseapp.configure()` and place it in `didFinishLaunchingWithOptions` method.

<Frame>
  <img />
</Frame>

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore //Here

@main
class AppDelegate: UIResponder, UIApplicationDelegate {



    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure() //Here
				FirebaseConfiguration.shared.setLoggerLevel(.min)
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

```

Click 'Next' and continue to the console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Let's build and run our project and see if we get Firebase log messages in the console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Create and upload our APNs authentication key

We will create and upload our APNs authentication key to the Firebase project settings.

<Frame>
  <img />
</Frame>

Navigate to [Apple Developer Member Center](https://developer.apple.com/account).

Head to the "Keys" section under "Certificates, IDs & Profiles".

<Frame>
  <img />
</Frame>

Create a new key.

<Frame>
  <img />
</Frame>

Select "Apple Push Notification Service".

<Frame>
  <img />
</Frame>

Click "Register".

<Frame>
  <img />
</Frame>

We have to download this key and upload it into Firebase.

<Frame>
  <img />
</Frame>

Head to "Project Settings".

<Frame>
  <img />
</Frame>

Click on Cloud Messaging, then click "Upload APNs Authentication Key".

<Frame>
  <img />
</Frame>

Now we can upload the dots p8 file.

<Frame>
  <img />
</Frame>

You must enter your `Key ID` and `Team ID`, which you can find in the top right corner.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Register for Remote Notifications

<Frame>
  <img />
</Frame>

1. Copy this code block and place it inside the `AppDelegate.swift` file using the `didFinishLaunchingWithOptions` method.
   We paste this code block under `firebaseApp.configure()`.

2. We need to conform to this delegate, so we will also create an `AppDelegate` extension at the bottom for `UNUserNotificationCenterDelegate`.

3. Add `import FirebaseMessaging` to the file.

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {



    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
}

```

## Access the Registration Token

To do this, we must first set the `Messaging.messaging().delegate = self` inside the `didFinishLaunchingWithOptions` method.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We will now add a 'Messaging' delegate extension to `AppDelegate.swift` file.

<Frame>
  <img />
</Frame>

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce on 13/01/2024.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {



    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        FirebaseConfiguration.shared.setLoggerLevel(.min)

        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()
        
        // Messaging Delegate
        
        Messaging.messaging().delegate = self

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
      // Receive displayed notifications for iOS 10 devices.
      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  willPresent notification: UNNotification) async
        -> UNNotificationPresentationOptions {
        let userInfo = notification.request.content.userInfo

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // ...

        // Print full message.
        print(userInfo)

        // Change this to your preferred presentation option
        return [[.alert, .sound]]
      }

      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  didReceive response: UNNotificationResponse) async {
        let userInfo = response.notification.request.content.userInfo

        // ...

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // Print full message.
        print(userInfo)
      }
    }
    


extension AppDelegate: MessagingDelegate {
  
  func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
    print("Firebase registration token: \(String(describing: fcmToken))")
    
    let dataDict: [String: String] = ["token": fcmToken ?? ""]
    NotificationCenter.default.post(
      name: Notification.Name("FCMToken"),
      object: nil,
      userInfo: dataDict
    )
    // TODO: If necessary send token to application server.
    // Note: This callback is fired at each app startup and whenever a new token is generated.
  }
  
  
}

```

## Receive messages in an Apple App

1. Copy this code block and place it in `UNUserNotificationCenterDelegate` extension.
2. Add the `didReceiveRemoteNotification`.
3. We must declare a `gcmMessageIDKey` inside of `AppDelegate`. We can define this as a `string` variable.

<Frame>
  <img />
</Frame>

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    let gcmMessageIDKey = "gcm.Message_ID"

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        FirebaseConfiguration.shared.setLoggerLevel(.min)

        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()
        
        // Messaging Delegate
        
        Messaging.messaging().delegate = self

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
      // Receive displayed notifications for iOS 10 devices.
      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  willPresent notification: UNNotification) async
        -> UNNotificationPresentationOptions {
        let userInfo = notification.request.content.userInfo

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // ...

        // Print full message.
        print(userInfo)

        // Change this to your preferred presentation option
        return [[.alert, .sound]]
      }

      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  didReceive response: UNNotificationResponse) async {
        let userInfo = response.notification.request.content.userInfo

        // ...

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // Print full message.
        print(userInfo)
      }
    
    func application(_ application: UIApplication,
                     didReceiveRemoteNotification userInfo: [AnyHashable: Any]) async
      -> UIBackgroundFetchResult {
      // If you are receiving a notification message while your app is in the background,
      // this callback will not be fired till the user taps on the notification launching the application.
      // TODO: Handle data of notification

      // With swizzling disabled you must let Messaging know about the message, for Analytics
      // Messaging.messaging().appDidReceiveMessage(userInfo)

      // Print message ID.
      if let messageID = userInfo[gcmMessageIDKey] {
        print("Message ID: \(messageID)")
      }

      // Print full message.
      print(userInfo)

      return UIBackgroundFetchResult.newData
    }

    
    }
    


extension AppDelegate: MessagingDelegate {
  
  func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
    print("Firebase registration token: \(String(describing: fcmToken))")
    
    let dataDict: [String: String] = ["token": fcmToken ?? ""]
    NotificationCenter.default.post(
      name: Notification.Name("FCMToken"),
      object: nil,
      userInfo: dataDict
    )
    // TODO: If necessary send token to application server.
    // Note: This callback is fired at each app startup and whenever a new token is generated.
  }
  
  
}

```

## Adding app capabilities

<Frame>
  <img />
</Frame>

Click on the plus sign (+) and select `Background Modes`.

<Frame>
  <img />
</Frame>

**Select the following options:**

* Background Fetch
* Remote Notifications
* Background Processing

<Frame>
  <img />
</Frame>

Add `Push Notifications` capabilities.

<Frame>
  <img />
</Frame>

## App Build

<Frame>
  <img />
</Frame>

It will ask if you want to receive notifications, and we will allow it.

<Frame>
  <img />
</Frame>

## Cloud Message Test

In your Firebase project, navigate to 'engage' section and click on 'messaging'.

<Frame>
  <img />
</Frame>

Click on "Send your first message".

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

We're going to enter the `notification title` and the `notification text`, then we're going to send the test message.

<Frame>
  <img />
</Frame>

We must copy and paste this FCM registration token to confirm our device (A physical or a simulator). You can find it in your Xcode console.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Click on 'Test'.

<Frame>
  <img />
</Frame>

You should see the notification on your device!

<Frame>
  <img />
</Frame>

## Novu account creation

<Frame>
  <img />
</Frame>

You can immediately configure FCM as a Push channel provider or navigate to the Integration Store.

<Frame>
  <img />
</Frame>

## Connecting FCM as a provider

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

You only need to configure FCM with Novu with the Firebase Service Accounts private key.

To acquire the account key JSON file for your service account, follow this instructions:

1. Select your project. Click the gear icon on the top of the sidebar.
2. Head to project settings.
3. Navigate to the service account tab.
4. Click "Generate New Private Key", then confirm by clicking "Generate Key".
5. Clicking Generate Key will download the JSON file.
6. Once the file is on your machine, paste the entire JSON file content in the Service Account field of the FCM provider in the integration store on Novu’s web dashboard.

Make sure your service account key JSON content contains these fields:

```JSON theme={null}

{
  "type": "service_account",
  "project_id": "PROJECT_ID",
  "private_key_id": "PRIVATE_KEY_ID",
  "private_key": "PRIVATE_KEY",
  "client_email": "FIREBASE_ADMIN_SDK_EMAIL",
  "client_id": "CLIENT_ID",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "CLIENT_X509_CERT_URL"
}

```

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Creating a workflow

In Novu, creating a workflow means establishing a blueprint for sending notifications within your app. This unified structure ties together email, in-app messages, SMS, push notifications, and chat into **one entity**.

Each workflow has a unique name and identifier and includes customized content for various channels, using `{{handlebars}}` variables for personalization.

This ensures consistent platform notifications and allows dynamic adjustments for individual subscribers, scenarios, and use cases.

Workflow creation is for streamlining automated notifications, enabling teams to communicate effectively without extensive technical expertise.

<Steps>
  <Step title="Nabigate to 'Workflows' tab and click on 'Blank Workflow'">
    <Frame>
      <img />
    </Frame>

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Add (Drag & Drop) the Push channel node to the workflow">
    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Click on the node, and start to modify the content. Once you are done, click on 'Update'">
    <Frame>
      <img />
    </Frame>
  </Step>
</Steps>

## Creating a subscriber

Creating a subscriber in Novu refers to the process of establishing a subscriber entity within the Novu platform. A subscriber is essentially the recipient of the notifications sent through Novu's system. When you create a subscriber, you're setting up the necessary information for Novu to send targeted notifications to that individual.

<Frame>
  <img />
</Frame>

<Steps>
  <Step title="Creating a subscriber">
    ```JSON theme={null}

    curl --location 'https://api.novu.co/v1/subscribers' \
    --header 'Content-Type: application/json' \
    --header 'Accept: application/json' \
    --header 'Authorization: ApiKey <YOUR_API_KEY>' \
    --data-raw '{
    "subscriberId": "12345678",
    "firstName": "Pawan",
    "lastName": "Jain",
    "email": "pawan.jain@domain.com",
    "phone": "+1234567890",
    "avatar": "avatar-url",
    "locale": "en-US",
    "data": {
      "isDeveloper": true,
      "customKey": "customValue"
      }
    }'

    ```

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Locating subscriber's FCM registration token">
    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Adding the registration token to the subscriber">
    <Note> Subscriber can have multiple device tokens </Note>

    Here, you can locate the Provider\_Identifier.

    <Frame>
      <img />
    </Frame>

    ```JSON theme={null}

        curl --request PUT \
      --url https://api.novu.co/v1/subscribers/{subscriber_id}/credentials \
    --header 'Content-Type: application/json' \
      --header 'Authorization: ApiKey <YOUR_API_KEY>' \
      --data '{
      "credentials":{
        "deviceTokens": ["token1", "token2"]
    },
      "integrationIdentifier":"<Provider_Identifier>",
      "providerId":"fcm"
    }'

    ```
  </Step>
</Steps>

## Sending a notification to iOS device with Novu

To send a notification with Novu, you are actually triggering a notification workflow.
You have the ability to test the trigger using the user interface or by calling Novu's API.

**Trigger a workflow via the API**

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "<REPLACE_WITH_DATA>"
         },
         "payload": {}
       }'

```

<Frame>
  <img />
</Frame>

## Dynamic Content

When we were creating the first workflow, we "Hardcoded" the content of the notification.

Now, we will determine the content when calling the API.

1. In the workflow, we should change the values of the `title` and the `body` to `{{title}}` and `{{body}}`.
   That way, we could insert values through the payload of the API call.

<Frame>
  <img />
</Frame>

2. Add a 'payload' object to the API call.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <REPLACE_WITH_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "This title was set via the Payload",
           "body": "Payload notification body"
         },
       }'

```

<Frame>
  <img />
</Frame>

## Sound of a notification

The name of a sound file in your app's main bundle or in the Library/Sounds folder of your app's container directory.
Specify the string "default" to play the system sound.

Use this key for regular notifications. For critical alerts, use the sound dictionary instead.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "Notification With Sound",
           "body": "Hello World from Novu"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "payload": {
                 "aps": {
                   "sound": "default" // configure sound to the notification
                 }
               }
             }
           }
         }
       }'

```

## Priority for notification

If you omit this header, APNs set the notification priority to `10`.

Specify `10` to send the notification immediately.

Specify `5` to send the notification based on power considerations on the user’s device.

Specify `1` to prioritize the device’s power considerations over all other factors for delivery and prevent awakening the device.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "apns-priority: 5",
           "body": "Novu's API"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "headers": {
				 "apns-priority":"5" //priority for notifications
			   },
               "payload": {
                 "aps": {}
               },
               "fcm_options": {}
             }
           }
         }
       }'

```

## Sending images

Up to this point, your notifications have all contained only text. But if you’ve received many notifications, you know that notifications can have rich content, such as images. It’d be great if your notifications showed users a nice image related to their content. Once again, Firebase makes this super simple.

To show an image in push notifications, you’ll need to create a ***Notification Service Extension***. This is a separate target in your app that runs in the background when your user receives a push notification. The service extension can receive a notification and change its contents before iOS shows the notification to the user.
You’ll use Firebase to send an image URL inside a notification.
You’ll then use a content extension to download the image and add it to the notification’s content.

In Xcode, go to File ▸ New ▸ Target…. Search for Notification Service Extension and select Next. Set a name and configure it to add to your main project.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Select **Finish**, and when prompted, select **Activate**.

<Frame>
  <img />
</Frame>

When you added the Firebase package to your project, it was only added to the your "main" (In my case it's "PushNotificationDemo") target, so now you need to add the necessary dependency to your new extension.
Open your app’s project settings and select the name you picked for the extention under Targets.

Under Frameworks and Libraries, select the + button, and search for FirebaseMessaging. Then, select Add. Your project should reflect the image below:

<Frame>
  <img />
</Frame>

Select the + button, and search for FirebaseMessaging. Then, select Add.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Now, open `NotificationService.swift`. This file is where you can customize notifications before the user sees them.

First, add the following import to the top of the file:
`import FirebaseMessaging`

Next, replace the contents of `didReceive(_:withContentHandler:)` with the following:

```Swift theme={null}

self.contentHandler = contentHandler
bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)
        
if let bestAttemptContent = bestAttemptContent {
// Modify the notification content here...
bestAttemptContent.title = "\(bestAttemptContent.title)"
            
// Call FIRMessaging extension helper API.

if let messagingContentHandler = self.contentHandler {
Messaging.serviceExtension().populateNotificationContent(bestAttemptContent, withContentHandler: messagingContentHandler)
 }
}

```

Typically, you’d have to search the field containing the image URL, download the image, and finish the presentation with the picture as an attachment.
Here, you’re using Firebase’s `FIRMessagingExtensionHelper` to perform all that work automatically in a straightforward helper method call.

Remember, iOS only allows you to download your attached image. If the extension’s code takes too long to run, the system will call `serviceExtensionTimeWillExpire()`.
This gives you a chance to gracefully finish up anything you are doing in the extension or to simply present the notification as is, which is the default implementation.

This is the entire `NotificationService.swift` file.

```Swift theme={null}

//
//  NotificationService.swift
//  Rich Notifications
//
//  Created by Emillien Pearce.
//

import UserNotifications
import FirebaseMessaging

class NotificationService: UNNotificationServiceExtension {

    var contentHandler: ((UNNotificationContent) -> Void)?
    var bestAttemptContent: UNMutableNotificationContent?

    override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
        
        self.contentHandler = contentHandler
        bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)
        
        if let bestAttemptContent = bestAttemptContent {
            // Modify the notification content here...
            bestAttemptContent.title = "\(bestAttemptContent.title)"
            
            // Call FIRMessaging extension helper API.
            if let messagingContentHandler = self.contentHandler {
                Messaging.serviceExtension().populateNotificationContent(bestAttemptContent, withContentHandler: messagingContentHandler)
            }
        }
    }
    
    override func serviceExtensionTimeWillExpire() {
        // Called just before the extension will be terminated by the system.
        // Use this as an opportunity to deliver your "best attempt" at modified content, otherwise the original push payload will be used.
        if let contentHandler = contentHandler, let bestAttemptContent =  bestAttemptContent {
            contentHandler(bestAttemptContent)
        }
    }

}

```

Let's **rebuild** our app again!

<Frame>
  <img />
</Frame>

When making the API call, we should include:

* "mutable-content": 1 inside the "aps" object.
* "image" in "fcm\_options" object,
* URL address of the image.

```JSON theme={null}

curl --location --request POST 'https://api.novu.co/v1/events/trigger' \
     --header 'Authorization: ApiKey <YOUR_API_KEY>' \
     --header 'Content-Type: application/json' \
     --data-raw '{
         "name": "untitled",
         "to": {
           "subscriberId": "12345678"
         },
         "payload": {
           "title": "This is a notification with an image",
           "body": "Check this out"
         },
         "overrides": {
           "fcm": {
             "apns": {
               "headers": {},
               "payload": {
        "aps": {
          "mutable-content": 1
                 }
               },
      "fcm_options": {
        "image": "https://www.planetware.com/wpimages/2020/02/france-in-pictures-beautiful-places-to-photograph-eiffel-tower.jpg"
               }
             }
           }
         }
       }'

```

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## Sending actionable notifications

1. Define Notification Actions:

In your `AppDelegate.swift` file, you should define the notification actions you want to add.
You can do this by creating a `UNNotificationAction` for each action you want to include.
For example, let's add two actions: "Accept" and "Reject".

```Swift theme={null}

// Add these lines inside your AppDelegate class, preferably below the existing extensions.

extension UNNotificationAction {
    static let accept = UNNotificationAction(
        identifier: "ACCEPT_ACTION",
        title: "Accept",
        options: [.foreground]
    )
    
    static let reject = UNNotificationAction(
        identifier: "REJECT_ACTION",
        title: "Reject",
        options: [.destructive, .foreground]
    )
}

```

2. Register Notification Category:

   You need to register the notification category with the actions you defined in your `didFinishLaunchingWithOptions` method:

   ```
   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
   // ... (your existing code)

   // Register notification category
   let acceptAction = UNNotificationAction.accept
   let rejectAction = UNNotificationAction.reject

   let messageCategory = UNNotificationCategory(
       identifier: "MESSAGE_CATEGORY",
       actions: [acceptAction, rejectAction],
       intentIdentifiers: [],
       options: []
   )

   UNUserNotificationCenter.current().setNotificationCategories([messageCategory])

   return true
   ```

}

````

3. Handle Action Taps:

Now, you need to handle the action taps in the `userNotificationCenter(_:didReceive response:)` method of your `AppDelegate`. 
You can check which action was tapped by inspecting the `response.actionIdentifier` property:

```Swift

func userNotificationCenter(_ center: UNUserNotificationCenter,
                            didReceive response: UNNotificationResponse) async {
    let userInfo = response.notification.request.content.userInfo

    if response.actionIdentifier == UNNotificationAction.accept.identifier {
        // Handle the "Accept" action
        print("User tapped Accept")
        // Perform the desired action for "Accept"
    } else if response.actionIdentifier == UNNotificationAction.reject.identifier {
        // Handle the "Reject" action
        print("User tapped Reject")
        // Perform the desired action for "Reject"
    } else {
        // Handle other actions or default behavior
        print("User tapped an action with identifier: \(response.actionIdentifier)")
    }
}

````

Your full `AppDelegate.swift` file should look like this:

```Swift theme={null}

//
//  AppDelegate.swift
//  PushNotificationDemo
//
//  Created by Emillien Pearce.
//

import UIKit
import FirebaseCore
import FirebaseMessaging

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    let gcmMessageIDKey = "gcm.Message_ID"

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        FirebaseApp.configure()
        FirebaseConfiguration.shared.setLoggerLevel(.min)

        
        // Register for Remote Notitifcations
        
        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
          options: authOptions,
          completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()
        
        // Register notification category
        let acceptAction = UNNotificationAction.accept
        let rejectAction = UNNotificationAction.reject
        
        let messageCategory = UNNotificationCategory(
            identifier: "MESSAGE_CATEGORY",
            actions: [acceptAction, rejectAction],
            intentIdentifiers: [],
            options: []
        )
        
        UNUserNotificationCenter.current().setNotificationCategories([messageCategory])
        
        // Messaging Delegate
        
        Messaging.messaging().delegate = self

        
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }


}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
      // Receive displayed notifications for iOS 10 devices.
      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  willPresent notification: UNNotification) async
        -> UNNotificationPresentationOptions {
        let userInfo = notification.request.content.userInfo

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // ...

        // Print full message.
        print(userInfo)

        // Change this to your preferred presentation option
        return [[.alert, .sound]]
      }

      func userNotificationCenter(_ center: UNUserNotificationCenter,
                                  didReceive response: UNNotificationResponse) async {
        let userInfo = response.notification.request.content.userInfo
          
          if response.actionIdentifier == UNNotificationAction.accept.identifier {
               // Handle the "Accept" action
               print("User tapped Accept")
               // Perform the desired action for "Accept"
           } else if response.actionIdentifier == UNNotificationAction.reject.identifier {
               // Handle the "Reject" action
               print("User tapped Reject")
               // Perform the desired action for "Reject"
           } else {
               // Handle other actions or default behavior
               print("User tapped an action with identifier: \(response.actionIdentifier)")
           }

        // ...

        // With swizzling disabled you must let Messaging know about the message, for Analytics
        // Messaging.messaging().appDidReceiveMessage(userInfo)

        // Print full message.
        print(userInfo)
          
          
      }
    
    func application(_ application: UIApplication,
                     didReceiveRemoteNotification userInfo: [AnyHashable: Any]) async
      -> UIBackgroundFetchResult {
      // If you are receiving a notification message while your app is in the background,
      // this callback will not be fired till the user taps on the notification launching the application.
      // TODO: Handle data of notification

      // With swizzling disabled you must let Messaging know about the message, for Analytics
      // Messaging.messaging().appDidReceiveMessage(userInfo)

      // Print message ID.
      if let messageID = userInfo[gcmMessageIDKey] {
        print("Message ID: \(messageID)")
      }

      // Print full message.
      print(userInfo)
          
          

      return UIBackgroundFetchResult.newData
    }

    
    }
    


extension AppDelegate: MessagingDelegate {
  
  func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
    print("Firebase registration token: \(String(describing: fcmToken))")
    
    let dataDict: [String: String] = ["token": fcmToken ?? ""]
    NotificationCenter.default.post(
      name: Notification.Name("FCMToken"),
      object: nil,
      userInfo: dataDict
    )
    // TODO: If necessary send token to application server.
    // Note: This callback is fired at each app startup and whenever a new token is generated.
  }
  
  
}

extension UNNotificationAction {
    static let accept = UNNotificationAction(
        identifier: "ACCEPT_ACTION",
        title: "Accept",
        options: [.foreground]
    )
    
    static let reject = UNNotificationAction(
        identifier: "REJECT_ACTION",
        title: "Reject",
        options: [.destructive, .foreground]
    )
}

```

Now, let’s trigger a notification with actionable buttons:

```JSON theme={null}

curl --location --request POST "https://api.novu.co/v1/events/trigger" \
     --header "Authorization: ApiKey 4de014990cfb201033014548be2db904" \
     --header "Content-Type: application/json" \
     --data-raw '{
    "name": "untitled",
    "to": {
        "subscriberId": "12345678"
    },
    "payload": {
        "title": "New Mission",
        "body": "Your mission, should you choose to accept it,"
    },
    "overrides": {
        "fcm": {
            "apns": {
                "payload": {
                    "aps": {
                        "category": "MESSAGE_CATEGORY"
                    }
                }
            }
        }
    }
}'

```

<Frame>
  <img />
</Frame>

## Additional resources

* [Generating a remote notification by Apple](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/generating_a_remote_notification)
* [Sending notification requests to APNs](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/sending_notification_requests_to_apns)


# How to Add Digest to Email Notifications
Source: https://v0.x-docs.novu.co/guides/add-digest-to-email-notifications

Leverage the digest functionality to send email notifications

# Introduction

In this guide, you’ll learn how to add digest functionality to email notifications. But before exploring the actual code, let’s understand what a digest notification is and how it works.

You can find the entire code(frontend as well as backend) for this app [here](https://github.com/novuhq/digest-email-app).

<Note>
  If, instead, you want to add digest to in-app notifications, we have a guide for that as well. Take a look [here](/guides/add-digest-to-inapp-notifications).
</Note>

### What is a Digest Notification?

Often when you associate notifications with user activity, the end user can be bombarded with messages because of the nature of the activity. Take for example the case of commenting in the context of a social media app. If you were to send a notification to a user for every comment they receive, and they happen to receive 100 comments, it could lead to user fatigue since you would have to send 100 messages.

This is where digest notifications come into the picture!

A digest notification is a notification that consolidates information from several notifications into one and delivers that notification to the end user instead of several separate messages.

### How does Digest Notification Work?

Novu has a built-in digest engine that collects multiple trigger events, aggregates them into a single message, and delivers it to the subscriber. You can use the digest engine by adding a ‘digest node’ to your workflow in the workflow editor in the [Novu dashboard](https://web.novu.co/workflows?utm_campaign=docs-digests). If you want to learn more about it, [this](/getting-started/concepts#digest) is a great place to start.

Let’s see it in action now!

# Add Digest Notification To An App

To get started with this, you need the following:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-digests) if you don’t have one yet.
* A working React development environment.

# Workflow setup in Novu

Once, you have these, follow the steps below:

1. Head over to the Novu Dashboard.
2. Click `Workflows` on the left sidebar of your Novu dashboard.
3. Click the `Create Workflow` button on the top right:

<Frame>
  <img />
</Frame>

Once you click the `create workflow` button, you’ll see a dropdown. Select `blank workflow` from the dropdown:

<Frame>
  <img />
</Frame>

You’ll now be taken to the workflow editor:

<Frame>
  <img />
</Frame>

Once here, you can add the channels you want to use for sending notifications and configure them. For this guide, we’ll use the `Email` channel. You’ll also see the `Digest` action on the right sidebar.

<Note>
  Each node that is added below the digest node will only be triggered after the specified time interval
</Note>

For example, in our case, say we want the email notification to be sent after every 6 hours. So, add the `digest` action below the `trigger node`, and add the `email` channel node below the `digest` node as shown below:

<Frame>
  <img />
</Frame>

The `digest` node allows you to set a specific time interval for when notifications should be sent:

<Frame>
  <img />
</Frame>

Once, you’ve configured it. Go ahead and configure the `email` channel as per your need:

<Frame>
  <img />
</Frame>

Here’s a brief explanation of all the options:

* **1-Preview:** This shows you a glimpse of what the email notification item will look like when delivered to the client.
* **2-Sender Name:** Lets you set the sender name for emails that the client will receive.
* **3-Subject:** This lets you define the subject line for the emails that the client will receive.
* **4-Filter:** This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.
* **5-Custom Code** - In custom code, you can write custom digest templates to show some/all parts of a message.
* **6-Test** - This allows you to send a test email to test if everything is working as per your wish.

You can write your own digest template in the 'custom code' section or just follow this guide as shown in the picture above. Once you’re done configuring this to your liking, click on the `update` button on the top right.

It’ll automatically create a trigger code that you can use in your app. To get it, click on the `get snippet` button on the top right and copy it:

<Frame>
  <img />
</Frame>

Now, let’s see how to add Novu to our app!

# Add Novu to the Backend and Configure it

In your backend, install the novu package using the following code:

```bash theme={null}
npm install @novu/node

```

Now, create a route that you want to hit when called from the front end. In our demo app, this is the route:

```jsx theme={null}
import express from 'express';

import { getEmailDigest } from '../controller/emaildigest.js';

const router = express.Router();

router.post('/sending-email-digest', getEmailDigest);

export default router;
```

Now, we need to write a controller function that will handle the logic for what is to be sent in the trigger function’s payload. In our case, this is the controller function:

```jsx theme={null}
import { sendEmailDigest } from '../novu/novu.js';

export const getEmailDigest = async (req, res) => {
  const { notif, email } = req.body;
  try {
    await sendEmailDigest(notif, email);
    res.status(201).json({ message: 'success', notif: notif });
  } catch (error) {
    res.status(409).json({ message: error.message });
  }
};
```

To make it modular, we’ll keep the trigger code in a separate function in a separate file (`novu.js`, in our case) and the trigger function is getting called in the controller function above by the name `getEmailDigest`.

If you’re following the guide, you’ve already copied the trigger function. But before we can add it to our app, we need one key thing - Subscribers.

Subscribers are users to which the notifications are sent. You can see a list of subscribers in the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-digests) as well.

In our app, we’ll create a subscriber in Node.js as we’re writing our backend in Node.js, but we also have backend [SDKs](/sdks/introduction) ([Node.js](https://github.com/novuhq/novu/tree/next/packages/node), [PHP](https://github.com/novuhq/novu-php), [.NET](https://github.com/novuhq/novu-dotnet), [Elixir](https://github.com/novuhq/novu-elixir), [Go](https://github.com/novuhq/go-novu), [Ruby](https://github.com/novuhq/novu-ruby), [Python](https://github.com/novuhq/novu-python), and [Kotlin](https://github.com/novuhq/novu-kotlin)) to choose from. The recommended way to create a subscriber in NodeJS is as follows:

```jsx theme={null}
await novu.subscribers.identify('digestEmailSub', {
  firstName: 'digest email subscriber',
  email: email,
});
```

Here, we’re creating a subscriber with the `subscriberID` of `digestEmailSub.` In most real-world scenarios, the `subscriberId` should be an alphanumeric entity like `adfa67y87ad0`. You can read more about subscribers [here](https://docs.novu.co/platform/subscribers/).

Back in our app, we can now add the trigger function:

```jsx theme={null}
import { Novu } from '@novu/node';

export const sendEmailDigest = async (notif, email) => {
  const novu = new Novu(process.env.YOUR_NOVU_API_KEY);
  await novu.subscribers.identify('digestEmailSub', {
    firstName: 'digest email subscriber',
    email: email,
  });

  novu.trigger('emaildigestworkflow', {
    to: {
      subscriberId: 'digestEmailSub',
      email: email,
    },
    payload: {
      notif: notif,
    },
  });
};
```

Now, we just need to hit the route defined above from the front end.

# Hit the backend route from the front end

From the front end, we just need to hit the route we had defined above. Below, I'm sharing the body component of the demo app I created to illustrate this:

```jsx theme={null}
const Body = () => {
  const [formInput, setFormInput] = useState({ notif: '', email: '' });
  const [buttonClicked, setButtonClicked] = useState(false);

  const onSubmitHandler = async (e) => {
    e.preventDefault();
    const response = await fetch(
      'https://emaildigestbackend.onrender.com/api/v1/sending-email-digest',
      {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(formInput),
      }
    );
    console.log(response.data);
    setFormInput({ notif: '' });
  };

  const handleClick = () => {
    setButtonClicked(true);

    // Reset the button feedback after a certain duration
    setTimeout(() => {
      setButtonClicked(false);
    }, 100);
  };

  const onChangeHandler = (e) => {
    const value = e.target.name === 'email' ? e.target.value.trim() : e.target.value;

    setFormInput((prev) => ({
      ...prev,
      [e.target.name]: value,
    }));
  };
  return (
    <div>
      <h1>Email Digest Playground</h1>
      <p>
        Don't know how to? Start{' '}
        <a className="underline" href="https://docs.novu.co/platform/digest/">
          {' '}
          here
        </a>
      </p>
      <form onSubmit={onSubmitHandler}>
        <div>
          <div>
            <label htmlFor="email" className="w-48">
              Email:
            </label>
            <input
              placeholder="Your Email here"
              value={formInput.email}
              id="email"
              name="email"
              onChange={onChangeHandler}
            />
          </div>
          <div>
            <label htmlFor="notif">Notification:</label>
            <textarea
              placeholder="Enter the notification text"
              value={formInput.notif}
              id="notif"
              name="notif"
              onChange={onChangeHandler}
            />
          </div>
        </div>

        <button onClick={handleClick} type="submit">
          <BiRightArrowAlt className="text-2xl" />
        </button>
      </form>
    </div>
  );
};
```

We're hitting the backend route we had created earlier. The backend has been deployed on render as can be seen in this code snippet above.

Congratulations on following the guide up until this point. We can style our app a little using [some TailwindCSS](https://github.com/novuhq/digest-email-app/blob/main/frontend/src/app.css).

If you’ve done everything as recommended, you’ll end up with an app that looks like this:

<Frame>
  <img />
</Frame>

In this app, when we enter the email id, some text in the input box, and click send, the notification appears in the inbox after the delay specified above (when we’re creating the workflow).

This is how we add digest to email notifications!


# How to Add Digest to In-App Notifications
Source: https://v0.x-docs.novu.co/guides/add-digest-to-inapp-notifications

Leverage the digest functionality to send in-app notifications

## Introduction

In this guide, you’ll learn how to add digest notifications to a React app. But before exploring the actual code, let’s understand what a digest notification is and how it works.

You can find the entire code(frontend as well as backend) for this app [here](https://github.com/novuhq/digest-learning-app/tree/main).

### What is a Digest Notification?

Often times when you associate notifications with user activity, the end user can be bombarded with messages because of the nature of the activity. Take for example the case of commenting in the context of a social media app. If you were to send a notification to a user for every comment they receive, and they happen to receive 100 comments, it could lead to user fatigue since you would have to send 100 messages.

This is where digest notifications come into the picture!

A digest notification is a notification that consolidates information from several notifications into one and delivers that notification to the end user instead of several separate messages.

### How does Digest Notification Work?

Novu has a built-in digest engine that collects multiple trigger events, aggregates them into a single message and delivers it to the subscriber. You can use the digest engine by adding a `digest node` to your workflow in the workflow editor in the [Novu dashboard](https://web.novu.co/workflows?utm_campaign=docs-digestsinapp).

Let’s see it in action now!

## Add Digest Notification To An App

To get started with this, you need the following:

* A Novu account. [Sign up for free](http://web.novu.co/?utm_campaign=docs-gs-digestsinapp) if you don’t have one yet.
* A working React development environment.

## Workflow setup in Novu

Once, you have these, follow the steps below:

1. Head over to the Novu Dashboard.
2. Click `Workflows` on the left sidebar of your Novu dashboard.
3. Click the `Create Workflow` button on the top right:

<Frame>
  <img />
</Frame>

Once you click the `create workflow` button, you’ll see a dropdown. Select `blank workflow` from the dropdown:

<Frame>
  <img />
</Frame>

You’ll now be taken to the workflow editor:

<Frame>
  <img />
</Frame>

Once here, you can add the channels you want to use for sending notifications and configure them. For this guide, we’ll use the `In-App` channel. You’ll also see the `Digest` action on the right sidebar.

<Note>
  Each node that is added below the digest node will only be triggered after the specified time interval
</Note>

For example, in our case, say we want the In-App notification to be sent after every 6 hours. Next, add the `digest` action below the `trigger node`, and add the `in-app` channel node below the `digest` node as shown below:

<Frame>
  <img />
</Frame>

The `digest` node allows you to set a specific time interval for when notifications should be sent:

<Frame>
  <img />
</Frame>

Once, you’ve configured it. Go ahead and configure the `in-app` channel as per your need:

<Frame>
  <img />
</Frame>

Here’s a brief explanation of all the options:

* **1-Preview**: This shows you a glimpse of what each notification item will look like in the Notification Center UI.
* **2-Avatar:** If turned on, each notification item will show the avatar of the subscriber.
* **3-Action:** With this, you can add a primary and secondary call to action button to each notification item.
* **4-Notification Feeds:** This displays a stream of specific notifications. You can have multiple feeds to show specific notifications in multiple tabs.
* **5-Redirect URL** - This is the URL to which a subscriber can be directed when they click on a notification item.
* **6-Filter** - This feature allows you to configure the criteria for delivering notifications. For instance, you can apply a filter based on a subscriber's online status to send them an email if they were online within the last hour.

In our case, we’re going to use the following:

<Frame>
  <img />
</Frame>

Once you’re done configuring this to your liking, click on the `update` button on the top right.
It’ll automatically create a trigger code that you can use in your app. To get it, click on the `get snippet` button on the top right and copy it:

<Frame>
  <img />
</Frame>

Now, let’s see how to add Novu to our app!

# Add Novu to the Backend and Configure it

In your backend, install the novu package using the following code:

```bash theme={null}
npm install @novu/node
```

Now, create a route which you want to hit when called from the front end. In our demo app, this is the route:

```jsx theme={null}
import express from 'express';
import { getDigest } from '../controller/digest.js';

const router = express.Router();

router.post('/sending-digest', getDigest);

export default router;
```

Now, we need to write a controller function that will handle the logic for what is to be sent in the trigger function’s payload. In our case, this is the controller function:

```jsx theme={null}
import { sendDigest } from '../novu/novu.js';

export const getDigest = async (req, res) => {
  const { name } = req.body;
  try {
    await sendDigest(name);
    res.status(201).json({ message: 'success', name: name });
  } catch (error) {
    res.status(409).json({ message: error.message });
  }
};
```

To make it modular, we’ll keep the trigger code in a separate function in a separate file (`novu.js`, in our case) and the trigger function is getting called in the controller function above by the name `getDigest`.

If you’re following the guide, you’ve already copied the trigger function. But before we can add it to our app, we need one key thing - **Subscribers.**

Subscribers are entities to which the notifications are sent. You can see a list of subscribers in the [Novu dashboard](https://web.novu.co/subscribers?utm_campaign=docs-digests-inapp) as well.

In our app, we’ll create a subscriber in Node.js as we’re writing our backend in Node.js, but we also have backend [SDKs](/sdks/introduction) (Node.js, PHP, .NET, Go, Ruby, Python and Kotlin) to choose from. The recommended way to create a subscriber in NodeJS is as follows:

```jsx theme={null}
await novu.subscribers.identify('aa234u787', {
  firstName: 'digest subscriber',
});
```

Here, we’re creating a subscriber with the `subscriberID` of `aa234u787.` You can read more about subscribers [here](/subscribers/subscribers).

Back in our app, we can now add the trigger function:

```jsx theme={null}
import { Novu } from '@novu/node';

export const sendDigest = async (name) => {
  const novu = new Novu(process.env.NOVU_API_KEY);

  await novu.subscribers.identify('aa234u787', {
    firstName: 'digest subscriber',
  });

  await novu.trigger('digest-showcase', {
    to: {
      subscriberId: 'aa234u787',
    },
    payload: {
      name: name,
    },
  });
};
```

Now, we just need to hit the route defined above from the front end and add Novu to it.

# Add Novu’s Notification Center to the front end

In the front end, install the Novu notification centre package using the following command:

```bash theme={null}
npm install @novu/notification-center

```

Now, import and render the component in your app. The code to do so is as follows:

```jsx theme={null}
import {
  NovuProvider,
  PopoverNotificationCenter,
  NotificationBell,
  IMessage,
} from '@novu/notification-center';

function Header() {
  function onNotificationClick(message: IMessage) {
    // your logic to handle the notification click
    if (message?.cta?.data?.url) {
window.location.href = message.cta.data.url;
    }
  }

  return (
    <NovuProvider subscriberId={'USER_ID'} applicationIdentifier={'APP_ID_FROM_ADMIN_PANEL'}>
      <PopoverNotificationCenter onNotificationClick={onNotificationClick}>
        {({ unseenCount }) => <NotificationBell unseenCount={unseenCount} />}
      </PopoverNotificationCenter>
    </NovuProvider>
  );
}

```

You can, of course, modify things as you need. For example, in our app, this is what we’ve done in the header:

```jsx theme={null}
import {
  NovuProvider,
  Popover