> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tako.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Send monitor firings to Slack

> Post each monitor firing to a Slack channel. Build a Slack workflow that starts from a webhook, register its trigger URL as a slack_workflow notification channel, and attach the channel to your monitors.

export const MonitorsExperimental = () => <Warning>
    <strong>Monitors is experimental.</strong> Request and payload shapes can change without a deprecation window. Monitors isn't recommended for production workflows.
  </Warning>;

<MonitorsExperimental />

A notification channel whose `kind` is `slack_workflow` posts each firing to a Slack workflow. The workflow receives the request, and posts the firing's `summary` to a Slack channel, such as "San Francisco 49ers beat Los Angeles Rams 27 to 20."

## Before you start

You need these things:

* A paid Slack plan. A workflow that starts from a webhook requires one.
* Permission to create workflows that start from a webhook. Slack workspace owners and admins can restrict who creates them.
* A [Tako API key](https://tako.com/console/api-keys).

## Set up the workflow and the channel

<Steps>
  <Step title="Create a workflow that starts from a webhook">
    In Slack, open Workflow Builder, and create a workflow. For how the workflow starts, choose **From a webhook**.
  </Step>

  <Step title="Add a variable for each key that Tako sends">
    Add a **text** variable for each of these 7 keys: `summary`, `monitor_name`, `monitor_type`, `monitor_id`, `occurred_at`, `event_id`, and `event_type`. Tako sends every value as a string, and it sends all 7 keys for every monitor type.
  </Step>

  <Step title="Add a step that posts the message">
    Add a **Send a message to a channel** step, and choose the Slack channel. In the message, click **Insert a variable**, and choose `summary`. To name the monitor in the message too, insert `monitor_name`.
  </Step>

  <Step title="Publish the workflow, and copy its URL">
    Publish the workflow. Slack gives it a web request URL that starts with `https://hooks.slack.com/triggers/`. Keep the URL secret, because anyone who has it can start the workflow.
  </Step>

  <Step title="Register the URL as a notification channel">
    Replace the URL with the one that Slack gave your workflow.

    ```bash theme={null}
    SLACK_TRIGGER_URL="https://hooks.slack.com/triggers/..."
    SLACK_WORKFLOW_CHANNEL_ID=$(curl -s -X POST https://tako.com/api/v1/notification_channels \
      -H "X-API-Key: $TAKO_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"name": "Game night workflow", "kind": "slack_workflow", "url": "'"$SLACK_TRIGGER_URL"'"}' \
      | jq -r .id)
    ```

    `SLACK_WORKFLOW_CHANNEL_ID` holds the notification channel's `id`.
  </Step>

  <Step title="Attach the notification channel to a monitor">
    To post a new monitor's firings to Slack, pass the notification channel's `id` in `channel_ids` when you [create the monitor](/api-reference/monitors-create). To add Slack to a monitor that exists, send the monitor's full list of notification channels. Set `MONITOR_ID` to the monitor's `id`, and `WEBHOOK_CHANNEL_ID` to the `id` of the webhook channel that you want to keep:

    ```bash theme={null}
    curl -X PATCH https://tako.com/api/v1/monitors/$MONITOR_ID \
      -H "X-API-Key: $TAKO_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"channel_ids": ["'"$WEBHOOK_CHANNEL_ID"'", "'"$SLACK_WORKFLOW_CHANNEL_ID"'"]}'
    ```

    `channel_ids` replaces the monitor's notification channels, so include every one that you want to keep.
  </Step>
</Steps>

## What the workflow receives

Each firing sends one flat JSON object of strings:

```json theme={null}
{
  "summary": "San Francisco 49ers beat Los Angeles Rams 27 to 20.",
  "monitor_name": "49ers wins",
  "monitor_type": "sports.game_result",
  "monitor_id": "5e2a9c14-7b3d-4f81-a0c6-2d9e8b7f1a43",
  "occurred_at": "2026-10-24T02:41:00+00:00",
  "event_id": "c8f1d2e7-3a4b-4c5d-9e6f-7a8b9c0d1e2f",
  "event_type": "monitor.fired"
}
```

| Key            | Value                                                                                       |
| -------------- | ------------------------------------------------------------------------------------------- |
| `summary`      | One sentence that describes the firing, with its values. Use it as the message.             |
| `monitor_name` | The `name` you gave the monitor.                                                            |
| `monitor_type` | The monitor's type, such as `sports.game_result`.                                           |
| `monitor_id`   | The monitor's id.                                                                           |
| `occurred_at`  | When the occurrence happened, in ISO 8601.                                                  |
| `event_id`     | The firing's id, as [List a monitor's firings](/api-reference/monitors-firings) returns it. |
| `event_type`   | `monitor.fired`.                                                                            |

Every monitor type sends the same 7 keys, so one workflow can post the firings of all your monitors.

## Good to know

* **`summary` carries the values.** The body holds no `payload`. To read a price or a score as its own field, create a `webhook` channel instead. See [Webhook deliveries](/documentation/integrating-tako/monitors/webhook-deliveries).
* **Slack accepts 1 request per second for each workflow.** If Slack responds with a `429`, Tako retries the delivery. For the retry schedule, see [How Tako retries](/documentation/integrating-tako/monitors/webhook-deliveries#how-tako-retries).
* **Tako pauses a notification channel after 2 consecutive failed deliveries.** If you unpublish the workflow, its deliveries fail, and Tako pauses the notification channel. Publish the workflow again, then [resume the notification channel](/api-reference/notification-channels-update).
* **A notification channel's URL is fixed.** If you replace the workflow, it gets a new trigger URL. Every notification channel counts toward your limit, paused or not, so delete the old notification channel first. Deleting it removes it from every monitor. Then register the new URL as a new notification channel, and attach it to your monitors with `PATCH`.
* **A `slack_workflow` notification channel counts toward your limit.** By default, you can hold 2 notification channels, of either kind.