Chat

The Chat channel delivers messages to your subscribers via their preferred chat platforms and application.

Messaging platforms vs. Messaging applications

• Messaging platforms: Ideal for structured, workplace communication. Use these to notify teams or users in collaborative environments. Examples: Slack, Teams
• Messaging apps: Best for consumer-facing messaging. Engage users directly through personal or group chats. Examples: WhatsApp, Telegram, Discord

Here’s the typical flow for sending a chat notification through Novu:

Add a chat provider

Start by adding a chat provider in the integration store on your Novu dashboard.
You can connect one or more integrations for different or even the same providers, for example, multiple Slack workspaces.

To learn how to add a chat provider, refer to the setup guide for that provider.

Add the chat channel to your workflow

Next, include a Chat step in your workflow.
This step defines when and how a chat message should be sent as part of your notification workflow.

Define the chat content

Within the Chat step editor, write the message body.
The editor supports dynamic data for personalized and contextual messages.

Store subscriber credentials

Each subscriber must have valid chat credentials, such as a webhookUrl or unique identifier, to receive chat notifications.
You can store or update these credentials using the Novu dashboard, API, or SDKs.

Trigger the workflow

Trigger the workflow using your application code. Novu automatically:

• Resolves the subscriber.
• Retrieves the correct credentials, for example, the webhookUrl.
• Selects the appropriate provider.
• Renders the message.
• Delivers it to the chat platform.

Configuring chat providers

When you add a chat provider in the Integration Store, you'll configure credentials specific to that provider.

Provider authentication

You may need to provide credentials specific to your chat provider, such as an API key, Client ID, or Client Secret. However, some providers, like Discord, may not require any global credentials to be set in the Integration Store.

Each provider has different requirements.

How to manages Chat credentials

The chat channel works by storing specific credentials for each subscriber. This credential is typically a webhookUrl that tells Novu where to send a message for that specific subscriber.

Before triggering a chat notification, you must update the subscriber with this webhookUrl.

Storing subscriber credentials

Use the subscribers.credentials.update method to store the webhookUrl for a specific subscriber and provider.

Checkout the API reference for more details.

const novu = new Novu({ secretKey: "<NOVU_SECRET_KEY>", // Required if using EU region // serverURL: "https://eu.api.novu.co", });

await novu.subscribers.credentials.update( { providerId: ChatOrPushProviderEnum.Discord, credentials: { webhookUrl: "<WEBHOOK_URL>", }, integrationIdentifier: "discord-MnGLxp8uy", }, "subscriberId" );

  </Tab>
  <Tab title="Python">
```python
import os
import novu_py
from novu_py import Novu

with Novu(secret_key=os.getenv("NOVU_SECRET_KEY", "")) as novu:
    novu.subscribers.credentials.update(
        subscriber_id="subscriberId",
        update_subscriber_channel_request_dto={
            "provider_id": novu_py.ChatOrPushProviderEnum.DISCORD,
            "credentials": {
                "webhook_url": "<WEBHOOK_URL>",
            },
            "integration_identifier": "discord-MnGLxp8uy",
        },
    )

novugo "github.com/novuhq/novu-go"
"github.com/novuhq/novu-go/models/components"

)

integrationIdentifier := "discord-MnGLxp8uy" webhookURL := "<WEBHOOK_URL>"

s := novugo.New(novugo.WithSecurity(os.Getenv("NOVU_SECRET_KEY")))

_, err := s.Subscribers.Credentials.Update(context.Background(), "subscriberId", components.UpdateSubscriberChannelRequestDto{ ProviderID: components.ChatOrPushProviderEnumDiscord, IntegrationIdentifier: &integrationIdentifier, Credentials: components.ChannelCredentials{ WebhookURL: &webhookURL, }, }, nil)

  </Tab>
  <Tab title="PHP">
```php
use novu;
use novu\Models\Components;

$sdk = novu\Novu::builder()
    ->setSecurity('<NOVU_SECRET_KEY>')
    ->build();

$sdk->subscribers->updateCredentials(
    subscriberId: 'subscriberId',
    updateSubscriberChannelRequestDto: new Components\UpdateSubscriberChannelRequestDto(
        providerId: Components\ChatOrPushProviderEnum::Discord,
        credentials: new Components\ChannelCredentials(
            webhookUrl: '<WEBHOOK_URL>',
        ),
        integrationIdentifier: 'discord-MnGLxp8uy',
    ),
);

var sdk = new NovuSDK(secretKey: "<NOVU_SECRET_KEY>");

await sdk.Subscribers.UpdateCredentialsAsync( subscriberId: "subscriberId", updateSubscriberChannelRequestDto: new UpdateSubscriberChannelRequestDto() { ProviderId = ChatOrPushProviderEnum.Discord, IntegrationIdentifier = "discord-MnGLxp8uy", Credentials = new ChannelCredentials() { WebhookUrl = "<WEBHOOK_URL>", }, } );

  </Tab>
  <Tab title="Java">
```java
import co.novu.Novu;
import co.novu.models.components.*;

Novu novu = Novu.builder()
    .secretKey("<NOVU_SECRET_KEY>")
    .build();

novu.subscribers().updateCredentials()
    .subscriberId("subscriberId")
    .body(UpdateSubscriberChannelRequestDto.builder()
        .providerId(ChatOrPushProviderEnum.DISCORD)
        .integrationIdentifier("discord-MnGLxp8uy")
        .credentials(ChannelCredentials.builder()
            .webhookUrl("<WEBHOOK_URL>")
            .build())
        .build())
    .call();

Supported providers

Here are the chat providers that are currently supported by Novu. Select any provider to see its detailed setup guide.