> ## Documentation Index
> Fetch the complete documentation index at: https://docs.novu.co/llms.txt
> Use this file to discover all available pages before exploring further.
# Slack Chat Integration with Novu
> Connect Slack to Novu to send workflow chat notifications through OAuth, deliver messages to channels or DMs, and format content with Block Kit.
This feature is currently in public beta, please contact us at [support@novu.co](mailto:support@novu.co) to enable it for your organization.
The Slack chat integration lets your application send notifications directly to your subscribers' Slack workspaces using their own Slack accounts and workspace permissions. With this integration, Novu can deliver messages to Slack channels, direct messages (DMs) to Slack users, and incoming webhooks. For incoming webhooks, Novu can use Slack's native channel picker during OAuth.
Novu handles the full lifecycle of Slack connections and message delivery. You define where notifications should be delivered, and Novu automatically routes each message to the correct Slack workspace, channel, or user.
This guide walks you through setting up Slack chat, connect workspaces, and deliver notifications to the exact Slack destinations your users expect it.
Trigger a workflow to deliver a message to a subscriber's Slack channel, DM, or webhook.
Send rich Slack messages with sections, buttons, and context blocks using trigger overrides or Framework.
The Chat step in the dashboard sends plain text by default. To send [Slack Block Kit](https://api.slack.com/block-kit) messages from a dashboard workflow, pass `blocks` in [trigger overrides](/platform/integrations/trigger-overrides) when you call the API. See [Format messages with Block Kit](#format-messages-with-block-kit) for examples, including `_passthrough` for raw Slack API fields.
Check out the [agents](/agents) documentation for more information on how to build agents using Slack.
## Configure a Slack app
Before integrating Slack chat with Novu, you must create and configure a Slack app. The Slack app manages the OAuth permissions, bot token scopes, and redirect URLs needed for Novu to connect to your users' workspaces securely.
**Token rotation is not supported.** Novu does not currently support Slack apps with **token rotation** enabled. If token rotation is turned on in your Slack app settings, bot tokens expire after about 12 hours and message delivery fails with errors such as `token_revoked` or `invalid_auth` until the workspace is manually reconnected.
Keep token rotation **disabled** on your Slack app until this is supported. Reach out to [support@novu.co](mailto:support@novu.co) if this is a blocker for your usecase.
### Create a Slack app
First, you need to create a Slack app. This provides you with the credential you need to create a Slack integration in Novu.
Sign in at the [Slack API dashboard](https://api.slack.com/apps).
In Slack, click **Create an App** to start a new app registration.
Choose **From scratch** and enter an app name and workspace.
Enter an app name of your choice in the **App Name** field.
Pick a Slack workspace to develop your app in.
Click **Create App**. You'll be directed to the **Basic Application** for the Slack app which contains the credentials you need for configuring Slack chat inside Novu:
* App ID
* Client ID
* Client Secret
### Configure scopes (Permissions)
Your app needs permission to perform actions like sending messages or reading channel lists.
In the sidebar, select **OAuth & Permissions**.
Scroll down to the **Scopes** section.
Under Bot Token Scopes, click **Add an OAuth Scope**.
* `chat:write`
* `chat:write.public`
* `channels:read`
* `groups:read`
* `users:read`
* `users:read.email`
* (optional) `incoming-webhook` if you want Slack's built-in channel picker.
These scopes are required for Novu to send messages, read channels and read users (for DMs and pickers). If you remove some of them, then certain features like channel or user selection might not work.
### Set the redirect URL
This tells Slack where to send the user after they successfully authorize your app.
In the sidebar, select **OAuth & Permissions**.
Scroll down to the **Redirect URLs** section.
Paste the Novu OAuth callback URL. Add the redirect URL that matches your Novu region:
```bash title="US region" theme={null}
https://api.novu.co/v1/integrations/chat/oauth/callback
```
```bash title="EU region" theme={null}
https://api.eu.novu.co/v1/integrations/chat/oauth/callback
```
## Configure Slack integration in Novu
Once your Slack app is set up, the next step is to configure the Slack Chat integration inside Novu.
Open the [Novu Dashboard](https://dashboard.novu.co).
In the sidebar, click **Integrations Store**.
In the **Integration Store**, click **Connect provider** to begin setup.
Fill in the required fields using the credentials from your Slack app:
* **Application Id**: Paste your Slack app App ID.
* **Client ID**: Paste your Slack App Client ID.
* **Client Secret**: Paste your Slack App Client Secret.
* **Redirect URL (Optional)**: Enter the URL where you want users to be redirected to after they successfully connect their workspace. If there is no redirect URL, then Novu closes the tab immediately after the OAuth flow completes.
Click **Create Integration** to create the Slack integration. Once saved, Novu is able to:
* Generate OAuth (Connect Slack) URLs for your users
* Receive Slack's OAuth callback.
* Store workspace tokens as connections.
You are now ready to implement the frontend flow to let users connect their workspaces.
## Let users connect their Slack workspace
To send messages to Slack, your users must first authorize Novu to access one of their Slack workspaces. This authorization happens through Slack's OAuth flow, which Novu generates and manages for you.
### Generate the OAuth URL
When a user clicks **Connect Slack** in your application, your backend should request a unique authorization URL from Novu.
The generated OAuth URL is valid for only 5 minutes. Do not cache this URL; generate it dynamically when the user initiates the flow.
```typescript theme={null}
import { Novu } from '@novu/api';
const novu = new Novu({ secretKey: "" });
const response = await novu.integrations.generateChatOAuthUrl({
integrationIdentifier: 'slack',
subscriberId: 'user-123',
context: {
tenant: 'orgId',
},
});
```
```python theme={null}
import os
from novu_py import Novu
with Novu(secret_key=os.getenv("NOVU_SECRET_KEY", "")) as novu:
response = novu.integrations.generate_chat_o_auth_url(generate_chat_oauth_url_request_dto={
"integration_identifier": "slack",
"subscriber_id": "user-123",
"context": {
"tenant": "orgId",
},
})
```
```go theme={null}
import (
"context"
"os"
novugo "github.com/novuhq/novu-go"
"github.com/novuhq/novu-go/models/components"
)
s := novugo.New(novugo.WithSecurity(os.Getenv("NOVU_SECRET_KEY")))
res, err := s.Integrations.GenerateChatOAuthURL(context.Background(), components.GenerateChatOauthURLRequestDto{
IntegrationIdentifier: "slack",
SubscriberID: novugo.String("user-123"),
Context: map[string]components.GenerateChatOauthURLRequestDtoContext{
"tenant": components.CreateGenerateChatOauthURLRequestDtoContextStr("orgId"),
},
}, nil)
```
```php theme={null}
use novu;
use novu\Models\Components;
$sdk = novu\Novu::builder()->setSecurity('')->build();
$response = $sdk->integrations->generateChatOAuthUrl(
generateChatOauthUrlRequestDto: new Components\GenerateChatOauthUrlRequestDto(
integrationIdentifier: 'slack',
subscriberId: 'user-123',
context: [
'tenant' => 'orgId',
],
),
);
```
```csharp theme={null}
using Novu;
using Novu.Models.Components;
var sdk = new NovuSDK(secretKey: "");
var response = await sdk.Integrations.GenerateChatOAuthUrlAsync(
generateChatOauthUrlRequestDto: new GenerateChatOauthUrlRequestDto() {
IntegrationIdentifier = "slack",
SubscriberId = "user-123",
Context = new Dictionary {
{ "tenant", "orgId" },
},
});
```
```java theme={null}
import co.novu.Novu;
import co.novu.models.components.*;
Novu novu = Novu.builder().secretKey("").build();
var response = novu.integrations().generateChatOAuthUrl()
.body(GenerateChatOauthUrlRequestDto.builder()
.integrationIdentifier("slack")
.subscriberId("user-123")
.context(java.util.Map.of("tenant", "orgId"))
.build())
.call();
```
```bash theme={null}
curl -L -X POST 'https://api.novu.co/v1/integrations/chat/oauth' \
-H 'Content-Type: application/json' \
-H 'Authorization: ApiKey ' \
-d '{
"integrationIdentifier": "slack",
"subscriberId": "user-123",
"context": {
"tenant": "orgId"
}
}'
```
Your application can support multiple Slack workspace connections per user or per tenant by triggering separate OAuth flows.
Novu allows one connection per (integration + subscriber + context). To connect multiple workspaces, trigger separate OAuth flows with different combinations of those values.
### Redirect the user
Once your backend returns the `oauthUrl`, open it in a new tab or window.
```tsx theme={null}
window.open(oauthUrl, '_blank');
```
Slack then guides the user through:
Reviewing your app's requested permissions
Approving the authorization
Redirecting back to Novu's callback URL
After the user approves access, Novu handles the rest of the OAuth flow automatically.
Novu stores the Slack access token for the connected workspace.
Novu creates a Slack connection for that workspace, it is referenced by `connectionIdentifier` when creating endpoints.You can also provider a custom `connectionIdentifier` to the `generateChatOAuthUrl()` and then connection with such identifier will be created instead of randomly generated one.
**Alternative: handle OAuth yourself.** Instead of `generateChatOAuthUrl()`, you can run the Slack OAuth flow with your own app, use the access token with Slack's APIs directly, then register the workspace with Novu via [`channelConnections.create`](/api-reference/channel-connections/create-a-channel-connection) (or `POST /v1/channel-connections`):
```tsx theme={null}
await novu.channelConnections.create({
integrationIdentifier: 'slack',
subscriberId: 'user-123',
context: { tenant: 'acme' },
workspace: {
id: authData.team.id, // Slack workspace ID from OAuth
name: authData.team.name,
},
auth: {
accessToken: authData.access_token,
},
});
```
## Choose delivery destinations
After a workspace is connected, you or users decide where in Slack to send the messages. This can either be a Slack channel, to a user or an incoming webhook URLs. After the delivery location has been selected, a Slack endpoint is then created for that location.
This is the typical flow for sending notifications to public or private channels.
```bash theme={null}
curl -X GET "https://slack.com/api/conversations.list" \
-H "Authorization: Bearer "
```
To learn more about using [Slack conversations API](https://docs.slack.dev/apis/web-api/using-the-conversations-api) to either get public or private channels, refer Slack documentation.
```typescript theme={null}
import { Novu } from '@novu/api';
const novu = new Novu({ secretKey: "" });
await novu.channelEndpoints.create({
subscriberId: 'user-123',
integrationIdentifier: 'slack',
connectionIdentifier: 'conn_slack_acme',
context: { tenant: 'acme' },
type: 'slack_channel',
endpoint: { channelId: 'C012345' },
});
```
```python theme={null}
import os
from novu_py import Novu
with Novu(secret_key=os.getenv("NOVU_SECRET_KEY", "")) as novu:
novu.channel_endpoints.create(request_body={
"subscriber_id": "user-123",
"integration_identifier": "slack",
"connection_identifier": "conn_slack_acme",
"context": {"tenant": "acme"},
"type": "slack_channel",
"endpoint": {"channel_id": "C012345"},
})
```
```go theme={null}
import (
"context"
"os"
novugo "github.com/novuhq/novu-go"
"github.com/novuhq/novu-go/models/components"
"github.com/novuhq/novu-go/models/operations"
)
s := novugo.New(novugo.WithSecurity(os.Getenv("NOVU_SECRET_KEY")))
res, err := s.ChannelEndpoints.Create(context.Background(), operations.CreateChannelEndpointsControllerCreateChannelEndpointRequestBodySlackChannel(
components.CreateSlackChannelEndpointDto{
SubscriberID: "user-123",
IntegrationIdentifier: "slack",
ConnectionIdentifier: novugo.String("conn_slack_acme"),
Context: map[string]any{
"tenant": "acme",
},
Type: components.CreateSlackChannelEndpointDtoTypeSlackChannel,
Endpoint: components.SlackChannelEndpointDto{ChannelID: "C012345"},
},
), nil)
```
```php theme={null}
use novu;
use novu\Models\Components;
$sdk = novu\Novu::builder()->setSecurity('')->build();
$sdk->channelEndpoints->create(
requestBody: new Components\CreateSlackChannelEndpointDto(
subscriberId: 'user-123',
integrationIdentifier: 'slack',
connectionIdentifier: 'conn_slack_acme',
context: [
'tenant' => 'acme',
],
type: Components\CreateSlackChannelEndpointDtoType::SlackChannel,
endpoint: new Components\SlackChannelEndpointDto(channelId: 'C012345'),
),
);
```
```csharp theme={null}
using Novu;
using Novu.Models.Components;
var sdk = new NovuSDK(secretKey: "");
await sdk.ChannelEndpoints.CreateAsync(
requestBody: CreateSlackChannelEndpointDto.CreateSlackChannel(
new CreateSlackChannelEndpointDto() {
SubscriberId = "user-123",
IntegrationIdentifier = "slack",
ConnectionIdentifier = "conn_slack_acme",
Context = new Dictionary {
{ "tenant", "acme" },
},
Type = CreateSlackChannelEndpointDtoType.SlackChannel,
Endpoint = new SlackChannelEndpointDto() { ChannelId = "C012345" },
}));
```
```java theme={null}
import co.novu.Novu;
import co.novu.models.components.*;
Novu novu = Novu.builder().secretKey("").build();
novu.channelEndpoints().create()
.requestBody(CreateSlackChannelEndpointDto.builder()
.subscriberId("user-123")
.integrationIdentifier("slack")
.connectionIdentifier("conn_slack_acme")
.context(java.util.Map.of("tenant", "acme"))
.type(CreateSlackChannelEndpointDtoType.SLACK_CHANNEL)
.endpoint(SlackChannelEndpointDto.builder().channelId("C012345").build())
.build())
.call();
```
```bash theme={null}
curl -L -X POST 'https://api.novu.co/v1/channel-endpoints' \
-H 'Content-Type: application/json' \
-H 'Authorization: ApiKey ' \
-d '{
"subscriberId": "user-123",
"integrationIdentifier": "slack",
"connectionIdentifier": "conn_slack_acme",
"context": {
"tenant": "acme"
},
"type": "slack_channel",
"endpoint": {
"channelId": "C012345"
}
}'
```
Use this to send personal messages and notifications directly to a specific user.
```bash theme={null}
curl -X GET "https://slack.com/api/users.list" \
-H "Authorization: Bearer "
```
For example, you can look up a Slack user ID by their email address, if you requested the `users:read.email` scope.
To learn more about using [Slack `users.list` method](https://docs.slack.dev/reference/methods/users.list), refer Slack documentation.
```typescript theme={null}
import { Novu } from '@novu/api';
const novu = new Novu({ secretKey: "" });
await novu.channelEndpoints.create({
type: 'slack_user',
subscriberId: 'user-123',
integrationIdentifier: 'slack',
connectionIdentifier: 'conn_slack_acme',
context: { tenant: 'acme' },
endpoint: { userId: 'U01234567' },
});
```
```python theme={null}
import os
from novu_py import Novu
with Novu(secret_key=os.getenv("NOVU_SECRET_KEY", "")) as novu:
novu.channel_endpoints.create(request_body={
"type": "slack_user",
"subscriber_id": "user-123",
"integration_identifier": "slack",
"connection_identifier": "conn_slack_acme",
"context": {"tenant": "acme"},
"endpoint": {"user_id": "U01234567"},
})
```
```go theme={null}
import (
"context"
"os"
novugo "github.com/novuhq/novu-go"
"github.com/novuhq/novu-go/models/components"
"github.com/novuhq/novu-go/models/operations"
)
s := novugo.New(novugo.WithSecurity(os.Getenv("NOVU_SECRET_KEY")))
res, err := s.ChannelEndpoints.Create(context.Background(), operations.CreateChannelEndpointsControllerCreateChannelEndpointRequestBodySlackUser(
components.CreateSlackUserEndpointDto{
SubscriberID: "user-123",
IntegrationIdentifier: "slack",
ConnectionIdentifier: novugo.String("conn_slack_acme"),
Context: map[string]any{
"tenant": "acme",
},
Type: components.CreateSlackUserEndpointDtoTypeSlackUser,
Endpoint: components.SlackUserEndpointDto{UserID: "U01234567"},
},
), nil)
```
```php theme={null}
use novu;
use novu\Models\Components;
$sdk = novu\Novu::builder()->setSecurity('')->build();
$sdk->channelEndpoints->create(
requestBody: new Components\CreateSlackUserEndpointDto(
subscriberId: 'user-123',
integrationIdentifier: 'slack',
connectionIdentifier: 'conn_slack_acme',
context: [
'tenant' => 'acme',
],
type: Components\CreateSlackUserEndpointDtoType::SlackUser,
endpoint: new Components\SlackUserEndpointDto(userId: 'U01234567'),
),
);
```
```csharp theme={null}
using Novu;
using Novu.Models.Components;
var sdk = new NovuSDK(secretKey: "");
await sdk.ChannelEndpoints.CreateAsync(
requestBody: CreateSlackUserEndpointDto.CreateSlackUser(
new CreateSlackUserEndpointDto() {
SubscriberId = "user-123",
IntegrationIdentifier = "slack",
ConnectionIdentifier = "conn_slack_acme",
Context = new Dictionary {
{ "tenant", "acme" },
},
Type = CreateSlackUserEndpointDtoType.SlackUser,
Endpoint = new SlackUserEndpointDto() { UserId = "U01234567" },
}));
```
```java theme={null}
import co.novu.Novu;
import co.novu.models.components.*;
Novu novu = Novu.builder().secretKey("").build();
novu.channelEndpoints().create()
.requestBody(CreateSlackUserEndpointDto.builder()
.subscriberId("user-123")
.integrationIdentifier("slack")
.connectionIdentifier("conn_slack_acme")
.context(java.util.Map.of("tenant", "acme"))
.type(CreateSlackUserEndpointDtoType.SLACK_USER)
.endpoint(SlackUserEndpointDto.builder().userId("U01234567").build())
.build())
.call();
```
```bash theme={null}
curl -L -X POST 'https://api.novu.co/v1/channel-endpoints' \
-H 'Content-Type: application/json' \
-H 'Authorization: ApiKey ' \
-d '{
"type": "slack_user",
"subscriberId": "user-123",
"integrationIdentifier": "slack",
"connectionIdentifier": "conn_slack_acme",
"context": {
"tenant": "acme"
},
"endpoint": {
"userId": "U01234567"
}
}'
```
If `incoming-webhook` scope was included when configuring the OAuth and permissions scopes in [Step 1.1](/platform/integrations/chat/slack#configure-scopes-permissions). Slack would show its own channel picker during the OAuth flow:
The subscriber picks a Slack channel where notifications should be delivered.
Novu automatically creates a webhook endpoint for that subscriber using that URL.
You don’t need to collect `channelId` yourself in this mode, Slack’s native channel picker handles it.
## Send notifications
Once you have at least one Slack connection, and one or more Slack endpoints. You can trigger the workflow:
```typescript theme={null}
import { Novu } from '@novu/api';
const novu = new Novu({ secretKey: "" });
await novu.trigger({
workflowId: "order-shipped",
to: { subscriberId: "user-123", },
payload: {
"orderNumber": "ORD-12345",
"trackingUrl": "https://acme.com/track/123"
},
context: {
"tenant": "acme"
},
});
```
```python theme={null}
import os
import novu_py
from novu_py import Novu
with Novu(secret_key=os.getenv("NOVU_SECRET_KEY", "")) as novu:
novu.trigger(trigger_event_request_dto=novu_py.TriggerEventRequestDto(
workflow_id="order-shipped",
to={"subscriber_id": "user-123"},
payload={
"orderNumber": "ORD-12345",
"trackingUrl": "https://acme.com/track/123"
},
context={
"tenant": "acme"
},
))
```
```go theme={null}
import (
"context"
"os"
novugo "github.com/novuhq/novu-go"
"github.com/novuhq/novu-go/models/components"
)
s := novugo.New(novugo.WithSecurity(os.Getenv("NOVU_SECRET_KEY")))
res, err := s.Trigger(context.Background(), components.TriggerEventRequestDto{
WorkflowID: "order-shipped",
To: components.CreateToSubscriberPayloadDto(components.SubscriberPayloadDto{
SubscriberID: "user-123",
}),
Payload: map[string]any{
"orderNumber": "ORD-12345",
"trackingUrl": "https://acme.com/track/123"
},
Context: map[string]any{
"tenant": "acme"
},
}, nil)
```
```php theme={null}
use novu;
use novu\Models\Components;
$sdk = novu\Novu::builder()->setSecurity('')->build();
$sdk->trigger(
triggerEventRequestDto: new Components\TriggerEventRequestDto(
workflowId: 'order-shipped',
to: new Components\SubscriberPayloadDto(subscriberId: 'user-123'),
payload: {
"orderNumber": "ORD-12345",
"trackingUrl": "https://acme.com/track/123"
},
context: {
"tenant": "acme"
},
),
);
```
```csharp theme={null}
using Novu;
using Novu.Models.Components;
var sdk = new NovuSDK(secretKey: "");
await sdk.TriggerAsync(triggerEventRequestDto: new TriggerEventRequestDto() {
WorkflowId = "order-shipped",
To = To.CreateSubscriberPayloadDto(new SubscriberPayloadDto() { SubscriberId = "user-123" }),
Payload = {
"orderNumber": "ORD-12345",
"trackingUrl": "https://acme.com/track/123"
},
Context = {
"tenant": "acme"
},
});
```
```java theme={null}
import co.novu.Novu;
import co.novu.models.components.*;
Novu novu = Novu.builder().secretKey("").build();
novu.trigger()
.body(TriggerEventRequestDto.builder()
.workflowId("order-shipped")
.to(To2.of(SubscriberPayloadDto.builder().subscriberId("user-123").build()))
.payload({
"orderNumber": "ORD-12345",
"trackingUrl": "https://acme.com/track/123"
})
.context({
"tenant": "acme"
})
.build())
.call();
```
```bash theme={null}
curl --location 'https://api.novu.co/v1/events/trigger' \
--header 'Content-Type: application/json' \
--header 'Authorization: ApiKey ' \
-d '{
"name": "order-shipped",
"to": [
"user-123"
],
"payload": {
"orderNumber": "ORD-12345",
"trackingUrl": "https://acme.com/track/123"
},
"context": {
"tenant": "acme"
}
}'
```
When the workflow is triggered, Novu will:
Novu looks up Slack endpoints that match the subscriber ID and context.
Novu sends the notification to each configured Slack destination. By default, the Chat step body is sent as plain text. To send Block Kit formatting, see [Format messages with Block Kit](#format-messages-with-block-kit).
**Message formatting:** The dashboard Chat step editor supports a plain text `body`. For rich Slack messages (sections, buttons, context blocks), use trigger overrides at send time or Framework provider overrides in code-first workflows. Digest summaries in the dashboard work as plain text using [digest variables](/platform/workflow/add-notification-content/personalize-content#digest-variables).
## Format messages with Block Kit
The Chat step in the Novu dashboard sends a plain text message body to Slack. There is no Block Kit editor in the workflow UI today.
You still have a few ways to send richer Slack messages:
| Approach | Best for |
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| **Chat step body (dashboard)** | Plain text summaries, including [digest variables](/platform/workflow/add-notification-content/personalize-content#digest-variables) |
| **Trigger overrides (API)** | Block Kit sections, buttons, and context blocks built from your trigger payload |
| **Framework provider overrides** | Full Block Kit control in code-first workflows, including dynamic digest formatting |
### Plain text and digest summaries
For digest workflows built in the dashboard, use digest variables in the Chat step body to build a text summary. For example:
```liquid theme={null}
{{ steps.digest-step.countSummary }}
{% for event in steps.digest-step.events %}
• {{ event.payload.title }}
{% endfor %}
```
This renders as plain text in Slack. It does not produce Block Kit formatting such as buttons or styled sections.
### Send Block Kit with trigger overrides
To send [Slack Block Kit](https://api.slack.com/block-kit) messages from a dashboard workflow, pass `blocks` in the `overrides` object when you trigger the workflow. The Chat step `body` from your template is still sent as the fallback `text` field unless you override it.
Copy the **step identifier** from your workflow in the dashboard and use it under `overrides.steps`.
```typescript theme={null}
import { Novu } from '@novu/api';
const novu = new Novu({ secretKey: '' });
await novu.trigger({
workflowId: 'comment-alert',
to: { subscriberId: 'user-123' },
payload: {
postTitle: 'Q1 planning thread',
postUrl: 'https://app.example.com/posts/456',
},
overrides: {
steps: {
'slack-chat-step': {
providers: {
slack: {
text: 'You have new comments',
blocks: [
{
type: 'section',
text: {
type: 'mrkdwn',
text: '*New comments on Q1 planning thread*',
},
},
{
type: 'actions',
elements: [
{
type: 'button',
text: { type: 'plain_text', text: 'View thread' },
url: 'https://app.example.com/posts/456',
},
],
},
],
},
},
},
},
},
});
```
```python theme={null}
import os
import novu_py
from novu_py import Novu
with Novu(secret_key=os.getenv('NOVU_SECRET_KEY', '')) as novu:
novu.trigger(trigger_event_request_dto=novu_py.TriggerEventRequestDto(
workflow_id='comment-alert',
to={'subscriber_id': 'user-123'},
payload={
'postTitle': 'Q1 planning thread',
'postUrl': 'https://app.example.com/posts/456',
},
overrides={
'steps': {
'slack-chat-step': {
'providers': {
'slack': {
'text': 'You have new comments',
'blocks': [
{
'type': 'section',
'text': {
'type': 'mrkdwn',
'text': '*New comments on Q1 planning thread*',
},
},
{
'type': 'actions',
'elements': [
{
'type': 'button',
'text': {'type': 'plain_text', 'text': 'View thread'},
'url': 'https://app.example.com/posts/456',
},
],
},
],
},
},
},
},
},
))
```
```go theme={null}
import (
"context"
"os"
novugo "github.com/novuhq/novu-go"
"github.com/novuhq/novu-go/models/components"
)
s := novugo.New(novugo.WithSecurity(os.Getenv("NOVU_SECRET_KEY")))
_, err := s.Trigger(context.Background(), components.TriggerEventRequestDto{
WorkflowID: "comment-alert",
To: components.CreateToSubscriberPayloadDto(components.SubscriberPayloadDto{
SubscriberID: "user-123",
}),
Payload: map[string]any{
"postTitle": "Q1 planning thread",
"postUrl": "https://app.example.com/posts/456",
},
Overrides: map[string]map[string]any{
"steps": {
"slack-chat-step": map[string]any{
"providers": map[string]any{
"slack": map[string]any{
"text": "You have new comments",
"blocks": []map[string]any{
{
"type": "section",
"text": map[string]any{
"type": "mrkdwn",
"text": "*New comments on Q1 planning thread*",
},
},
{
"type": "actions",
"elements": []map[string]any{
{
"type": "button",
"text": map[string]any{
"type": "plain_text",
"text": "View thread",
},
"url": "https://app.example.com/posts/456",
},
},
},
},
},
},
},
},
},
}, nil)
```
```php theme={null}
use novu;
use novu\Models\Components;
$sdk = novu\Novu::builder()->setSecurity('')->build();
$sdk->trigger(
triggerEventRequestDto: new Components\TriggerEventRequestDto(
workflowId: 'comment-alert',
to: new Components\SubscriberPayloadDto(subscriberId: 'user-123'),
payload: [
'postTitle' => 'Q1 planning thread',
'postUrl' => 'https://app.example.com/posts/456',
],
overrides: [
'steps' => [
'slack-chat-step' => [
'providers' => [
'slack' => [
'text' => 'You have new comments',
'blocks' => [
[
'type' => 'section',
'text' => [
'type' => 'mrkdwn',
'text' => '*New comments on Q1 planning thread*',
],
],
[
'type' => 'actions',
'elements' => [
[
'type' => 'button',
'text' => ['type' => 'plain_text', 'text' => 'View thread'],
'url' => 'https://app.example.com/posts/456',
],
],
],
],
],
],
],
],
],
),
);
```
```csharp theme={null}
using Novu;
using Novu.Models.Components;
using System.Collections.Generic;
var sdk = new NovuSDK(secretKey: "");
await sdk.TriggerAsync(triggerEventRequestDto: new TriggerEventRequestDto() {
WorkflowId = "comment-alert",
To = To.CreateSubscriberPayloadDto(new SubscriberPayloadDto() { SubscriberId = "user-123" }),
Payload = new Dictionary() {
{ "postTitle", "Q1 planning thread" },
{ "postUrl", "https://app.example.com/posts/456" },
},
Overrides = new Overrides() {
Steps = new Dictionary>>() {
{ "slack-chat-step", new Dictionary>() {
{ "providers", new Dictionary() {
{ "slack", new Dictionary() {
{ "text", "You have new comments" },
{ "blocks", new List>() {
new Dictionary() {
{ "type", "section" },
{ "text", new Dictionary() {
{ "type", "mrkdwn" },
{ "text", "*New comments on Q1 planning thread*" },
} },
},
new Dictionary() {
{ "type", "actions" },
{ "elements", new List>() {
new Dictionary() {
{ "type", "button" },
{ "text", new Dictionary() {
{ "type", "plain_text" },
{ "text", "View thread" },
} },
{ "url", "https://app.example.com/posts/456" },
},
} },
},
} },
} },
} },
} },
},
},
});
```
```java theme={null}
import co.novu.Novu;
import co.novu.models.components.*;
import java.util.List;
import java.util.Map;
Novu novu = Novu.builder().secretKey("").build();
novu.trigger()
.body(TriggerEventRequestDto.builder()
.workflowId("comment-alert")
.to(To2.of(SubscriberPayloadDto.builder().subscriberId("user-123").build()))
.payload(Map.of(
"postTitle", "Q1 planning thread",
"postUrl", "https://app.example.com/posts/456"))
.overrides(TriggerEventRequestDtoOverrides.builder()
.additionalProperties(Map.of(
"steps", Map.of(
"slack-chat-step", Map.of(
"providers", Map.of(
"slack", Map.of(
"text", "You have new comments",
"blocks", List.of(
Map.of(
"type", "section",
"text", Map.of(
"type", "mrkdwn",
"text", "*New comments on Q1 planning thread*")),
Map.of(
"type", "actions",
"elements", List.of(
Map.of(
"type", "button",
"text", Map.of("type", "plain_text", "text", "View thread"),
"url", "https://app.example.com/posts/456")))))))))
.build())
.build())
.call();
```
```bash theme={null}
curl -X POST 'https://api.novu.co/v1/events/trigger' \
-H 'Content-Type: application/json' \
-H 'Authorization: ApiKey ' \
-d '{
"name": "comment-alert",
"to": { "subscriberId": "user-123" },
"payload": {
"postTitle": "Q1 planning thread",
"postUrl": "https://app.example.com/posts/456"
},
"overrides": {
"steps": {
"slack-chat-step": {
"providers": {
"slack": {
"text": "You have new comments",
"blocks": [
{
"type": "section",
"text": {
"type": "mrkdwn",
"text": "*New comments on Q1 planning thread*"
}
},
{
"type": "actions",
"elements": [
{
"type": "button",
"text": { "type": "plain_text", "text": "View thread" },
"url": "https://app.example.com/posts/456"
}
]
}
]
}
}
}
}
}
}'
```
Replace `slack-chat-step` with the step identifier from your workflow. Step-level overrides take priority over workflow-level overrides.
#### Workflow-level overrides
If your workflow has a single Slack Chat step, you can apply Block Kit to all Slack steps in that workflow without targeting a step ID:
```json theme={null}
"overrides": {
"providers": {
"slack": {
"blocks": [
{
"type": "section",
"text": { "type": "mrkdwn", "text": "*Deploy succeeded*" }
}
]
}
}
}
```
### Send extra Slack fields with `_passthrough`
Use `_passthrough` when you need raw [Slack `chat.postMessage`](https://api.slack.com/methods/chat.postMessage) fields that are not exposed in the dashboard. Values in `_passthrough.body` are merged last and take priority over other override fields.
```typescript theme={null}
await novu.trigger({
workflowId: 'comment-alert',
to: { subscriberId: 'user-123' },
payload: {
postTitle: 'Q1 planning thread',
postUrl: 'https://app.example.com/posts/456',
},
overrides: {
steps: {
'slack-chat-step': {
providers: {
slack: {
_passthrough: {
body: {
text: 'You have new comments',
unfurl_links: false,
blocks: [
{
type: 'section',
text: {
type: 'mrkdwn',
text: '*New comments on Q1 planning thread*',
},
},
{
type: 'context',
elements: [
{
type: 'mrkdwn',
text: 'Sent via Novu',
},
],
},
],
},
},
},
},
},
},
},
});
```
```python theme={null}
novu.trigger(trigger_event_request_dto=novu_py.TriggerEventRequestDto(
workflow_id='comment-alert',
to={'subscriber_id': 'user-123'},
payload={
'postTitle': 'Q1 planning thread',
'postUrl': 'https://app.example.com/posts/456',
},
overrides={
'steps': {
'slack-chat-step': {
'providers': {
'slack': {
'_passthrough': {
'body': {
'text': 'You have new comments',
'unfurl_links': False,
'blocks': [
{
'type': 'section',
'text': {
'type': 'mrkdwn',
'text': '*New comments on Q1 planning thread*',
},
},
{
'type': 'context',
'elements': [
{
'type': 'mrkdwn',
'text': 'Sent via Novu',
},
],
},
],
},
},
},
},
},
},
},
))
```
```go theme={null}
_, err := s.Trigger(context.Background(), components.TriggerEventRequestDto{
WorkflowID: "comment-alert",
To: components.CreateToSubscriberPayloadDto(components.SubscriberPayloadDto{
SubscriberID: "user-123",
}),
Payload: map[string]any{
"postTitle": "Q1 planning thread",
"postUrl": "https://app.example.com/posts/456",
},
Overrides: map[string]map[string]any{
"steps": {
"slack-chat-step": map[string]any{
"providers": map[string]any{
"slack": map[string]any{
"_passthrough": map[string]any{
"body": map[string]any{
"text": "You have new comments",
"unfurl_links": false,
"blocks": []map[string]any{
{
"type": "section",
"text": map[string]any{
"type": "mrkdwn",
"text": "*New comments on Q1 planning thread*",
},
},
},
},
},
},
},
},
},
},
}, nil)
```
```php theme={null}
$sdk->trigger(
triggerEventRequestDto: new Components\TriggerEventRequestDto(
workflowId: 'comment-alert',
to: new Components\SubscriberPayloadDto(subscriberId: 'user-123'),
payload: [
'postTitle' => 'Q1 planning thread',
'postUrl' => 'https://app.example.com/posts/456',
],
overrides: [
'steps' => [
'slack-chat-step' => [
'providers' => [
'slack' => [
'_passthrough' => [
'body' => [
'text' => 'You have new comments',
'unfurl_links' => false,
'blocks' => [
[
'type' => 'section',
'text' => [
'type' => 'mrkdwn',
'text' => '*New comments on Q1 planning thread*',
],
],
],
],
],
],
],
],
],
],
),
);
```
```csharp theme={null}
await sdk.TriggerAsync(triggerEventRequestDto: new TriggerEventRequestDto() {
WorkflowId = "comment-alert",
To = To.CreateSubscriberPayloadDto(new SubscriberPayloadDto() { SubscriberId = "user-123" }),
Payload = new Dictionary() {
{ "postTitle", "Q1 planning thread" },
{ "postUrl", "https://app.example.com/posts/456" },
},
Overrides = new Overrides() {
Steps = new Dictionary>>() {
{ "slack-chat-step", new Dictionary>() {
{ "providers", new Dictionary() {
{ "slack", new Dictionary() {
{ "_passthrough", new Dictionary() {
{ "body", new Dictionary() {
{ "text", "You have new comments" },
{ "unfurl_links", false },
{ "blocks", new List>() {
new Dictionary() {
{ "type", "section" },
{ "text", new Dictionary() {
{ "type", "mrkdwn" },
{ "text", "*New comments on Q1 planning thread*" },
} },
},
} },
} },
} },
} },
} },
} },
},
},
});
```
```java theme={null}
novu.trigger()
.body(TriggerEventRequestDto.builder()
.workflowId("comment-alert")
.to(To2.of(SubscriberPayloadDto.builder().subscriberId("user-123").build()))
.payload(Map.of(
"postTitle", "Q1 planning thread",
"postUrl", "https://app.example.com/posts/456"))
.overrides(TriggerEventRequestDtoOverrides.builder()
.additionalProperties(Map.of(
"steps", Map.of(
"slack-chat-step", Map.of(
"providers", Map.of(
"slack", Map.of(
"_passthrough", Map.of(
"body", Map.of(
"text", "You have new comments",
"unfurl_links", false,
"blocks", List.of(
Map.of(
"type", "section",
"text", Map.of(
"type", "mrkdwn",
"text", "*New comments on Q1 planning thread*"))))))))))
.build())
.build())
.call();
```
```bash theme={null}
curl -X POST 'https://api.novu.co/v1/events/trigger' \
-H 'Content-Type: application/json' \
-H 'Authorization: ApiKey ' \
-d '{
"name": "comment-alert",
"to": { "subscriberId": "user-123" },
"payload": {
"postTitle": "Q1 planning thread",
"postUrl": "https://app.example.com/posts/456"
},
"overrides": {
"steps": {
"slack-chat-step": {
"providers": {
"slack": {
"_passthrough": {
"body": {
"text": "You have new comments",
"unfurl_links": false,
"blocks": [
{
"type": "section",
"text": {
"type": "mrkdwn",
"text": "*New comments on Q1 planning thread*"
}
},
{
"type": "context",
"elements": [
{
"type": "mrkdwn",
"text": "Sent via Novu"
}
]
}
]
}
}
}
}
}
}
}
}'
```
For a full guide on how overrides work, including workflow-level and step-level scopes, see [Trigger overrides](/platform/integrations/trigger-overrides).
### Block Kit with digest workflows
Trigger overrides are set when you call the trigger API. They work well when each trigger carries the data you need to build the message.
For [digest workflows](/platform/workflow/add-and-configure-steps/configure-action-steps/digest), Novu batches multiple triggers into one notification. The Chat step body can use [digest variables](/platform/workflow/add-notification-content/personalize-content#digest-variables) to summarize batched events, but `overrides` are not re-evaluated with that aggregated data. To build Block Kit dynamically from a digest batch, use [Framework provider overrides](/framework/typescript/steps#provider-overrides) in a code-first workflow.
## Using Slack with agents
Slack is a supported [agent provider](/agents/get-started/agents-and-providers). Connect your Slack app to an agent so users can message in channels or DMs and get replies in the same thread, without building Slack event handling yourself.
Learn how Novu agents work, including managed and custom code agents.
### What you get
When Slack is connected to an agent:
* Users message your app in Slack and your agent responds in the same thread
* Conversations appear in the dashboard under **Agent Conversations**
* Supported content includes text, markdown, files, interactive cards, reactions, and typing indicators
See [agent conversations](/agents/conversations#supported-platforms) for capabilities across all providers.
### Agent conversations vs. workflow notifications
| Use case | What happens |
| ------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| **Agent conversation** | The user messages your Slack app and your agent replies in the same thread. |
| **Workflow notification** | You trigger a workflow with a Chat step and Novu sends a one-way message to the subscriber's linked Slack destination. |
Both can use the same Slack integration. Your agent handles back-and-forth conversations while workflows send updates such as deploy alerts to the same workspace.
## Related
Pass Slack `blocks` and `_passthrough` fields when triggering a workflow from your application.
Connect Slack and other providers to an agent.