Send Slack notifications from your app with one API call.

Both routes send through your Slack app and an active Slack integration in your Notifly environment. They differ in where the message goes and what you store.

1. In the workflow editor, add a Chat step and write the message. It can use the trigger's payload, such as {{payload.service}}.
2. Trigger the workflow for a subscriber. Before the step runs, Notifly checks that subscriber's preferences for the chat channel, and an opted-out step is skipped with the reason recorded.
3. Notifly finds where that subscriber's Slack messages go, through the environment's active Slack integration: a Slack user or channel from a workspace connection, or the webhook URL saved on the subscriber.
4. It sends with chat.postMessage and the bot token, or posts to the webhook, and records Slack's answer in the activity feed. A subscriber with no Slack destination gets no message, and the activity feed says so.

Put a digest step ahead of the chat step when a burst of events should arrive as one Slack message.

1. In your Slack app, turn on Incoming Webhooks, add a webhook to the channel and copy its URL.
2. In the dashboard, open Integration Store, choose Connect Provider, open the Chat tab and connect Slack with your app's credentials, as the Slack integration guide shows.
3. Create each subscriber who should receive messages there and save the webhook URL on them. Saving credentials for a subscriber id Notifly has not seen is rejected.
4. Trigger the workflow that has the Chat step.

// npm install @notiflyio/api@0.1.26
import { Notifly } from "@notiflyio/api";

const secretKey = process.env.NOTIFLY_SECRET_KEY;
if (!secretKey) throw new Error("NOTIFLY_SECRET_KEY is not set");
const notifly = new Notifly({ security: { secretKey } });

// Once per subscriber: create them (saving credentials for an unknown subscriber id is rejected),
// then save the incoming webhook their Slack messages go to.
await notifly.subscribers.create({ subscriberId: "user_123" });
await notifly.subscribers.credentials.update(
  {
    providerId: "slack",
    credentials: { webhookUrl: "https://hooks.slack.com/services/T0000000/B0000000/XXXXXXXXXXXXXXXXXXXXXXXX" },
  },
  "user_123",
);

// Any time after that: trigger the workflow that has a Chat step.
await notifly.trigger({
  workflowId: "deploy-finished",
  to: "user_123",
  payload: { service: "billing-api", status: "succeeded" },
});

# Once per subscriber: create them, then save their incoming webhook URL.
curl -X POST https://api.notifly.io/v1/subscribers \
  -H "Authorization: ApiKey $NOTIFLY_SECRET_KEY" \
  -H "Content-Type: application/json" \
  -d '{"subscriberId":"user_123"}'

curl -X PUT https://api.notifly.io/v1/subscribers/user_123/credentials \
  -H "Authorization: ApiKey $NOTIFLY_SECRET_KEY" \
  -H "Content-Type: application/json" \
  -d '{"providerId":"slack","credentials":{"webhookUrl":"https://hooks.slack.com/services/T0000000/B0000000/XXXXXXXXXXXXXXXXXXXXXXXX"}}'

# Any time after that: trigger the workflow.
curl -X POST https://api.notifly.io/v1/events/trigger \
  -H "Authorization: ApiKey $NOTIFLY_SECRET_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"deploy-finished","to":{"subscriberId":"user_123"},"payload":{"service":"billing-api","status":"succeeded"}}'

Notifly checks that the webhook URL is a safe public address before it posts, and a blocked URL fails the send. See the REST API docs for authentication and environments.

For direct messages, let each user approve your Slack app once. Your backend creates a connect link, the user approves it in Slack, and Notifly stores the workspace connection.

// npm install @notiflyio/api@0.1.26
import { Notifly } from "@notiflyio/api";

const secretKey = process.env.NOTIFLY_SECRET_KEY;
if (!secretKey) throw new Error("NOTIFLY_SECRET_KEY is not set");
const notifly = new Notifly({ security: { secretKey } });

// Create a connect link for the signed-in user (valid for 5 minutes).
const { result } = await notifly.integrations.generateConnectOAuthUrl({
  integrationIdentifier: "slack-workspace", // the Identifier of your Slack integration
  subscriberId: "user_123",
  autoLinkUser: true, // also link the Slack user who approves the install
});
// Redirect the user to result.url and let them approve your app in Slack.

With autoLinkUser the Slack user who approves is linked to that subscriber, so a later trigger addressed to user_123 reaches them in Slack. The install asks for the bot scopes chat:write, chat:write.public, channels:read, groups:read, users:read and users:read.email unless you pass your own scope list.

Destinations belong to subscribers, not to the workflow. Save a different webhook URL for each subscriber, or connect each user's Slack, and one workflow reaches every one of them. A trigger addressed to a list of subscribers or to a topic fans out the same way, as Workflows describes.

Anything under overrides.providers.slack is merged into the message Notifly sends, converted to Slack's snake_case: unfurlLinks: false arrives as unfurl_links.

await notifly.trigger({
  workflowId: "deploy-finished",
  to: "user_123",
  payload: { service: "billing-api", status: "succeeded" },
  overrides: { providers: { slack: { unfurlLinks: false } } },
});

When Slack refuses a bot message, the step fails with the error Slack returned, such as Slack API Error: channel_not_found. A webhook that Slack answers with an error status, such as a revoked URL, fails with Chat webhook URL blocked: Request failed with status 404. Either way the activity feed records it.