Send Slack messages through Courier

Prerequisites

A Slack account

Setup

Add the Slack integration in Courier

Go to the and select Slack. Click “Install”.

Create and configure a Slack app

Go to the Slack Apps page and click “Create an App”.
Choose “From scratch”, name your app, and select your development workspace.
Under “OAuth & Permissions”, add these Bot Token Scopes: chat:write, im:write, users:read, users:read.email.
Click “Install App to Workspace” and authorize.
Copy the Bot User OAuth Access Token (starts with xoxb-).

The OAuth and Permissions page in Slack with the bot token scopes added — Slack OAuth Scopes

Design a Slack notification template

Go to the Courier and click + New > Message Template. Select Slack from your integrations. In the sidebar, click the new Slack block to open the Slack template editor. Add your message content.

Send a test message

Click Preview, then Create Test Event. Enter your bot token in the Access Token field. Click Send. Your message appears in Slack.

Profile requirements

Slack addresses the recipient by channel, user id, or email, so the profile you send to needs a slack object holding an access_token and one target. Store both once with , which merges into the profile and creates it if it does not exist:

Channel
User id
Email

The channel id, not its name. access_token is the bot token from your Slack app. It sits on the profile beside the target.

const profile = await client.profiles.create('user_123', {
  profile: {
    slack: {
      access_token: 'xoxb-xxxxx',
      channel: 'CL2MR6HEX',
    },
  },
});

profile = client.profiles.create(
    user_id="user_123",
    profile={
        "slack": {
            "access_token": "xoxb-xxxxx",
            "channel": "CL2MR6HEX",
        },
    },
)

curl --request POST \
  --url https://api.courier.com/profiles/user_123 \
  --header "Authorization: Bearer $COURIER_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
    "profile": {
      "slack": {
        "access_token": "xoxb-xxxxx",
        "channel": "CL2MR6HEX"
      }
    }
  }'

profile = courier.profiles.create(
  "user_123",
  profile: {
    slack: {
      access_token: "xoxb-xxxxx",
      channel: "CL2MR6HEX"
    }
  }
)

profile, err := client.Profiles.New(
	context.TODO(),
	"user_123",
	courier.ProfileNewParams{
		Profile: map[string]any{
			"slack": map[string]any{
				"access_token": "xoxb-xxxxx",
				"channel": "CL2MR6HEX",
			},
		},
	},
)

ProfileCreateParams params = ProfileCreateParams.builder()
    .userId("user_123")
    .profile(ProfileCreateParams.Profile.builder()
        .putAdditionalProperty("slack", JsonValue.from(java.util.Map.of(
            "access_token", "xoxb-xxxxx",
            "channel", "CL2MR6HEX")))
        .build())
    .build();
ProfileCreateResponse profile = client.profiles().create(params);

$profile = $client->profiles->create('user_123', profile: [
  'slack' => [
    'access_token' => 'xoxb-xxxxx',
    'channel' => 'CL2MR6HEX',
  ],
]);

ProfileCreateParams parameters = new()
{
    UserID = "user_123",
    Profile = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
        """
        {
          "slack": {
            "access_token": "xoxb-xxxxx",
            "channel": "CL2MR6HEX"
          }
        }
        """
    ),
};
var profile = await client.Profiles.Create(parameters);

courier profiles create \
  --api-key "$COURIER_API_KEY" \
  --user-id user_123 \
  --profile '{"slack":{"access_token":"xoxb-xxxxx","channel":"CL2MR6HEX"}}'

With Courier MCP, save the Slack channel CL2MR6HEX and my bot token on user_123.

Slack opens a direct message with that user. access_token is the bot token from your Slack app. It sits on the profile beside the target.

const profile = await client.profiles.create('user_123', {
  profile: {
    slack: {
      access_token: 'xoxb-xxxxx',
      user_id: 'UEFNTF6QL',
    },
  },
});

profile = client.profiles.create(
    user_id="user_123",
    profile={
        "slack": {
            "access_token": "xoxb-xxxxx",
            "user_id": "UEFNTF6QL",
        },
    },
)

curl --request POST \
  --url https://api.courier.com/profiles/user_123 \
  --header "Authorization: Bearer $COURIER_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
    "profile": {
      "slack": {
        "access_token": "xoxb-xxxxx",
        "user_id": "UEFNTF6QL"
      }
    }
  }'

profile = courier.profiles.create(
  "user_123",
  profile: {
    slack: {
      access_token: "xoxb-xxxxx",
      user_id: "UEFNTF6QL"
    }
  }
)

profile, err := client.Profiles.New(
	context.TODO(),
	"user_123",
	courier.ProfileNewParams{
		Profile: map[string]any{
			"slack": map[string]any{
				"access_token": "xoxb-xxxxx",
				"user_id": "UEFNTF6QL",
			},
		},
	},
)

ProfileCreateParams params = ProfileCreateParams.builder()
    .userId("user_123")
    .profile(ProfileCreateParams.Profile.builder()
        .putAdditionalProperty("slack", JsonValue.from(java.util.Map.of(
            "access_token", "xoxb-xxxxx",
            "user_id", "UEFNTF6QL")))
        .build())
    .build();
ProfileCreateResponse profile = client.profiles().create(params);

$profile = $client->profiles->create('user_123', profile: [
  'slack' => [
    'access_token' => 'xoxb-xxxxx',
    'user_id' => 'UEFNTF6QL',
  ],
]);

ProfileCreateParams parameters = new()
{
    UserID = "user_123",
    Profile = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
        """
        {
          "slack": {
            "access_token": "xoxb-xxxxx",
            "user_id": "UEFNTF6QL"
          }
        }
        """
    ),
};
var profile = await client.Profiles.Create(parameters);

courier profiles create \
  --api-key "$COURIER_API_KEY" \
  --user-id user_123 \
  --profile '{"slack":{"access_token":"xoxb-xxxxx","user_id":"UEFNTF6QL"}}'

With Courier MCP, save the Slack user id UEFNTF6QL and my bot token on user_123.

Slack resolves the address to a user, then direct-messages them. access_token is the bot token from your Slack app. It sits on the profile beside the target.

const profile = await client.profiles.create('user_123', {
  profile: {
    slack: {
      access_token: 'xoxb-xxxxx',
      email: 'sarah@acme-corp.com',
    },
  },
});

profile = client.profiles.create(
    user_id="user_123",
    profile={
        "slack": {
            "access_token": "xoxb-xxxxx",
            "email": "sarah@acme-corp.com",
        },
    },
)

curl --request POST \
  --url https://api.courier.com/profiles/user_123 \
  --header "Authorization: Bearer $COURIER_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
    "profile": {
      "slack": {
        "access_token": "xoxb-xxxxx",
        "email": "sarah@acme-corp.com"
      }
    }
  }'

profile = courier.profiles.create(
  "user_123",
  profile: {
    slack: {
      access_token: "xoxb-xxxxx",
      email: "sarah@acme-corp.com"
    }
  }
)

profile, err := client.Profiles.New(
	context.TODO(),
	"user_123",
	courier.ProfileNewParams{
		Profile: map[string]any{
			"slack": map[string]any{
				"access_token": "xoxb-xxxxx",
				"email": "sarah@acme-corp.com",
			},
		},
	},
)

ProfileCreateParams params = ProfileCreateParams.builder()
    .userId("user_123")
    .profile(ProfileCreateParams.Profile.builder()
        .putAdditionalProperty("slack", JsonValue.from(java.util.Map.of(
            "access_token", "xoxb-xxxxx",
            "email", "sarah@acme-corp.com")))
        .build())
    .build();
ProfileCreateResponse profile = client.profiles().create(params);

$profile = $client->profiles->create('user_123', profile: [
  'slack' => [
    'access_token' => 'xoxb-xxxxx',
    'email' => 'sarah@acme-corp.com',
  ],
]);

ProfileCreateParams parameters = new()
{
    UserID = "user_123",
    Profile = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
        """
        {
          "slack": {
            "access_token": "xoxb-xxxxx",
            "email": "sarah@acme-corp.com"
          }
        }
        """
    ),
};
var profile = await client.Profiles.Create(parameters);

courier profiles create \
  --api-key "$COURIER_API_KEY" \
  --user-id user_123 \
  --profile '{"slack":{"access_token":"xoxb-xxxxx","email":"sarah@acme-corp.com"}}'

With Courier MCP, save the Slack email sarah@acme-corp.com and my bot token on user_123.

Order of precedence. Set more than one of channel, user_id, or email and Courier uses them in that order.

Then send to user_id and Courier resolves the address. For a one-off with no stored profile, pass it inline instead: "to": { "slack": { "access_token": "xoxb-xxxxx", "channel": "CL2MR6HEX" } }.

Send by user id

The call in every language, and the rest of the profile object.

Send to a recipient

Send to user id
Send to slack

Courier reads slack off the saved profile, so preferences apply and the value can change without touching this code.

const { requestId } = await courier.send.message({
  message: {
    to: {
      user_id: "user_123",
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
  },
});

response = client.send.message(
    message={
        "to": {
            "user_id": "user_123",
        },
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
    },
)

curl -X POST https://api.courier.com/send \
  -H "Authorization: Bearer $COURIER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": {
      "to": {
        "user_id": "user_123"
      },
      "template": "nt_01kx4h2jdafq8bk9aftxak4b40"
    }
  }'

response = courier.send_.message(
  message: {
    to: {
      user_id: "user_123"
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40"
  }
)

response, err := client.Send.Message(context.TODO(), courier.SendMessageParams{
	Message: courier.SendMessageParamsMessage{
		To: courier.SendMessageParamsMessageToUnion{
			OfUserRecipient: &shared.UserRecipientParam{
				UserID: courier.String("user_123"),
			},
		},
		Template: courier.String("nt_01kx4h2jdafq8bk9aftxak4b40"),
	},
})

SendMessageParams params = SendMessageParams.builder()
    .message(SendMessageParams.Message.builder()
        .to(UserRecipient.builder().userId("user_123").build())
        .template("nt_01kx4h2jdafq8bk9aftxak4b40")
        .build())
    .build();
SendMessageResponse response = client.send().message(params);

$response = $client->send->message(
  message: [
    'to' => [
      'user_id' => 'user_123',
    ],
    'template' => 'nt_01kx4h2jdafq8bk9aftxak4b40',
  ],
);

SendMessageParams parameters = new()
{
    Message = new()
    {
        To = new UserRecipient { UserID = "user_123" },
        Template = "nt_01kx4h2jdafq8bk9aftxak4b40",
    },
};

var response = await client.Send.Message(parameters);

courier send message \
  --api-key "$COURIER_API_KEY" \
  --message.to '{"user_id": "user_123"}' \
  --message.template nt_01kx4h2jdafq8bk9aftxak4b40

With Courier MCP, send my template to user_123 by email.

Pass it inline instead and nothing is stored. Swap this to object into the call on the other tab.

const { requestId } = await courier.send.message({
  message: {
    to: {
      slack: {
        access_token: "xoxb-xxxxx",
        email: "sarah@acme-corp.com",
      },
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
  },
});

response = client.send.message(
    message={
        "to": {
            "slack": {
                "access_token": "xoxb-xxxxx",
                "email": "sarah@acme-corp.com",
            },
        },
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
    },
)

curl -X POST https://api.courier.com/send \
  -H "Authorization: Bearer $COURIER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": {
      "to": {
        "slack": {
          "access_token": "xoxb-xxxxx",
          "email": "sarah@acme-corp.com"
        }
      },
      "template": "nt_01kx4h2jdafq8bk9aftxak4b40"
    }
  }'

response = courier.send_.message(
  message: {
    to: {
      slack: {
        access_token: "xoxb-xxxxx",
        email: "sarah@acme-corp.com"
      }
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40"
  }
)

response, err := client.Send.Message(context.TODO(), courier.SendMessageParams{
	Message: courier.SendMessageParamsMessage{
		To: courier.SendMessageParamsMessageToUnion{
			OfSlackRecipient: &shared.SlackRecipientParam{
				Slack: shared.SlackParamOfSendToSlackEmail("xoxb-xxxxx", "sarah@acme-corp.com"),
			},
		},
		Template: courier.String("nt_01kx4h2jdafq8bk9aftxak4b40"),
	},
})

client.send().message(SendMessageParams.builder()
    .message(SendMessageParams.Message.builder()
        .to(SlackRecipient.builder()
            .slack(SendToSlackEmail.builder()
                .accessToken("xoxb-xxxxx")
                .email("sarah@acme-corp.com")
                .build())
            .build())
        .template("nt_01kx4h2jdafq8bk9aftxak4b40")
        .build())
    .build());

$response = $client->send->message(
  message: [
    'to' => [
      'slack' => [
        'access_token' => 'xoxb-xxxxx',
        'email' => 'sarah@acme-corp.com',
      ],
    ],
    'template' => 'nt_01kx4h2jdafq8bk9aftxak4b40',
  ],
);

SendMessageParams parameters = new()
{
    Message = new()
    {
        To = new SlackRecipient
        {
            Slack = new SendToSlackEmail
            {
                AccessToken = "xoxb-xxxxx",
                Email = "sarah@acme-corp.com",
            },
        },
        Template = "nt_01kx4h2jdafq8bk9aftxak4b40",
    },
};

var response = await client.Send.Message(parameters);

courier send message \
  --api-key "$COURIER_API_KEY" \
  --message.to '{"slack": {"access_token": "xoxb-xxxxx", "email": "sarah@acme-corp.com"}}' \
  --message.template nt_01kx4h2jdafq8bk9aftxak4b40

With Courier MCP, send my template to sarah@acme-corp.com on Slack.

Overrides

covers the two levels and which one wins. You can override the payload sent to Slack’s chat.postMessage using providers.slack.override.body. This is useful for advanced formatting, interactivity, and threading.

Unfurl links

const { requestId } = await courier.send.message({
  message: {
    to: {
      user_id: "user_123",
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    providers: {
      slack: {
        override: {
          body: {
            unfurl_links: true,
          },
        },
      },
    },
  },
});

response = client.send.message(
    message={
        "to": {
          "user_id": "user_123",
        },
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
        "providers": {
            "slack": {
                "override": {
                  "body": {
                    "unfurl_links": True,
                  },
                },
            },
        },
    },
)

curl -X POST https://api.courier.com/send \
  -H "Authorization: Bearer $COURIER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
      "message": {
        "to": {
          "user_id": "user_123"
        },
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
        "providers": {
          "slack": {
            "override": {
              "body": {
                "unfurl_links": true
              }
            }
          }
        }
      }
    }'

response = courier.send_.message(
  message: {
    to: {
      user_id: "user_123"
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    providers: {
      "slack" => {
        override: {
          body: {
            unfurl_links: true
          }
        }
      }
    }
  }
)

response, err := client.Send.Message(context.TODO(), courier.SendMessageParams{
	Message: courier.SendMessageParamsMessage{
		To: courier.SendMessageParamsMessageToUnion{
			OfUserRecipient: &shared.UserRecipientParam{
				UserID: courier.String("user_123"),
			},
		},
		Template: courier.String("nt_01kx4h2jdafq8bk9aftxak4b40"),
		Providers: shared.MessageProvidersParam{
			"slack": shared.MessageProvidersTypeParam{
				Override: map[string]any{
					"body": map[string]any{
						"unfurl_links": true,
					},
				},
			},
		},
	},
})

SendMessageParams params = SendMessageParams.builder()
    .message(SendMessageParams.Message.builder()
        .to(UserRecipient.builder().userId("user_123").build())
        .template("nt_01kx4h2jdafq8bk9aftxak4b40")
        .providers(MessageProviders.builder()
            .putAdditionalProperty("slack", JsonValue.from(java.util.Map.of(
                "override", java.util.Map.of("body", java.util.Map.of("unfurl_links", true)))))
            .build())
        .build())
    .build();
SendMessageResponse response = client.send().message(params);

$response = $client->send->message(
  message: [
    'to' => [
      'user_id' => 'user_123',
    ],
    'template' => "nt_01kx4h2jdafq8bk9aftxak4b40",
    'providers' => [
      'slack' => [
        'override' => [
          'body' => [
            'unfurl_links' => true,
          ],
        ],
      ],
    ],
  ],
);

SendMessageParams parameters = new()
{
    Message = new()
    {
        To = new UserRecipient { UserID = "user_123" },
        Template = "nt_01kx4h2jdafq8bk9aftxak4b40",
        Providers = new Dictionary<string, MessageProvidersType>()
        {
            {
                "slack",
                new()
                {
                    Override = new Dictionary<string, JsonElement>()
                    {
                        { "body", JsonSerializer.SerializeToElement(new { unfurl_links = true }) },
                    },
                }
            },
        },
    },
};

var response = await client.Send.Message(parameters);

courier send message \
  --api-key "$COURIER_API_KEY" \
  --message.to '{"user_id": "user_123"}' \
  --message.template nt_01kx4h2jdafq8bk9aftxak4b40 \
  --message.providers '{"slack": {"override": {"body": {"unfurl_links": true}}}}'

With Courier MCP, send my template to user_123 on Slack and let links unfurl.

Slack blocks (Block Kit)

Send rich, interactive layouts using Slack blocks:

const { requestId } = await courier.send.message({
  message: {
    to: {
      user_id: "user_123",
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    providers: {
      slack: {
        override: {
          body: {
            blocks: [
              {
                type: "header",
                text: {
                  type: "plain_text",
                  text: "Welcome!",
                },
              },
              {
                type: "section",
                text: {
                  type: "mrkdwn",
                  text: "This is a *section* block.",
                },
              },
            ],
            text: "Fallback plain text.",
          },
        },
      },
    },
  },
});

response = client.send.message(
    message={
        "to": {
          "user_id": "user_123",
        },
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
        "providers": {
            "slack": {
                "override": {
                  "body": {
                    "blocks": [
                      {
                        "type": "header",
                        "text": {
                          "type": "plain_text",
                          "text": "Welcome!",
                        },
                      },
                      {
                        "type": "section",
                        "text": {
                          "type": "mrkdwn",
                          "text": "This is a *section* block.",
                        },
                      },
                    ],
                    "text": "Fallback plain text.",
                  },
                },
            },
        },
    },
)

curl -X POST https://api.courier.com/send \
  -H "Authorization: Bearer $COURIER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
      "message": {
        "to": {
          "user_id": "user_123"
        },
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
        "providers": {
          "slack": {
            "override": {
              "body": {
                "blocks": [
                  {
                    "type": "header",
                    "text": {
                      "type": "plain_text",
                      "text": "Welcome!"
                    }
                  },
                  {
                    "type": "section",
                    "text": {
                      "type": "mrkdwn",
                      "text": "This is a *section* block."
                    }
                  }
                ],
                "text": "Fallback plain text."
              }
            }
          }
        }
      }
    }'

response = courier.send_.message(
  message: {
    to: {
      user_id: "user_123"
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    providers: {
      "slack" => {
        override: {
          body: {
            blocks: [
              {
                type: "header",
                text: {
                  type: "plain_text",
                  text: "Welcome!"
                }
              },
              {
                type: "section",
                text: {
                  type: "mrkdwn",
                  text: "This is a *section* block."
                }
              }
            ],
            text: "Fallback plain text."
          }
        }
      }
    }
  }
)

response, err := client.Send.Message(context.TODO(), courier.SendMessageParams{
	Message: courier.SendMessageParamsMessage{
		To: courier.SendMessageParamsMessageToUnion{
			OfUserRecipient: &shared.UserRecipientParam{
				UserID: courier.String("user_123"),
			},
		},
		Template: courier.String("nt_01kx4h2jdafq8bk9aftxak4b40"),
		Providers: shared.MessageProvidersParam{
			"slack": shared.MessageProvidersTypeParam{
				Override: map[string]any{
					"body": map[string]any{
						"blocks": []any{
							map[string]any{
								"type": "header",
								"text": map[string]any{
									"type": "plain_text",
									"text": "Welcome!",
								},
							},
							map[string]any{
								"type": "section",
								"text": map[string]any{
									"type": "mrkdwn",
									"text": "This is a *section* block.",
								},
							},
						},
						"text": "Fallback plain text.",
					},
				},
			},
		},
	},
})

SendMessageParams params = SendMessageParams.builder()
    .message(SendMessageParams.Message.builder()
        .to(UserRecipient.builder().userId("user_123").build())
        .template("nt_01kx4h2jdafq8bk9aftxak4b40")
        .providers(MessageProviders.builder()
            .putAdditionalProperty("slack", JsonValue.from(java.util.Map.of(
                "override", java.util.Map.of("body", java.util.Map.of("blocks", java.util.List.of(java.util.Map.of("type", "header", "text", java.util.Map.of("type", "plain_text", "text", "Welcome!")), java.util.Map.of("type", "section", "text", java.util.Map.of("type", "mrkdwn", "text", "This is a *section* block."))), "text", "Fallback plain text.")))))
            .build())
        .build())
    .build();
SendMessageResponse response = client.send().message(params);

$response = $client->send->message(
  message: [
    'to' => [
      'user_id' => 'user_123',
    ],
    'template' => "nt_01kx4h2jdafq8bk9aftxak4b40",
    'providers' => [
      'slack' => [
        'override' => [
          'body' => [
            'blocks' => [
              [
                'type' => 'header',
                'text' => [
                  'type' => 'plain_text',
                  'text' => 'Welcome!',
                ],
              ],
              [
                'type' => 'section',
                'text' => [
                  'type' => 'mrkdwn',
                  'text' => 'This is a *section* block.',
                ],
              ],
            ],
            'text' => 'Fallback plain text.',
          ],
        ],
      ],
    ],
  ],
);

SendMessageParams parameters = new()
{
    Message = new()
    {
        To = new UserRecipient { UserID = "user_123" },
        Template = "nt_01kx4h2jdafq8bk9aftxak4b40",
        Providers = new Dictionary<string, MessageProvidersType>()
        {
            {
                "slack",
                new()
                {
                    Override = new Dictionary<string, JsonElement>()
                    {
                        { "body", JsonSerializer.SerializeToElement(new { blocks = new[] { new { type = "header", text = new { type = "plain_text", text = "Welcome!" } }, new { type = "section", text = new { type = "mrkdwn", text = "This is a *section* block." } } }, text = "Fallback plain text." }) },
                    },
                }
            },
        },
    },
};

var response = await client.Send.Message(parameters);

courier send message \
  --api-key "$COURIER_API_KEY" \
  --message.to '{"user_id": "user_123"}' \
  --message.template nt_01kx4h2jdafq8bk9aftxak4b40 \
  --message.providers '{"slack": {"override": {"body": {"blocks": [{"type": "header", "text": {"type": "plain_text", "text": "Welcome!"}}, {"type": "section", "text": {"type": "mrkdwn", "text": "This is a *section* block."}}], "text": "Fallback plain text."}}}}'

With Courier MCP, send my template to user_123 on Slack using Block Kit blocks.

Design and preview your blocks visually with the Slack Block Kit Builder.

Replying in a thread

To reply to a thread, set the thread_ts value:

const { requestId } = await courier.send.message({
  message: {
    to: {
      user_id: "user_123",
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    providers: {
      slack: {
        override: {
          body: {
            thread_ts: "1234567890.123456",
          },
        },
      },
    },
  },
});

response = client.send.message(
    message={
        "to": {
          "user_id": "user_123",
        },
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
        "providers": {
            "slack": {
                "override": {
                  "body": {
                    "thread_ts": "1234567890.123456",
                  },
                },
            },
        },
    },
)

curl -X POST https://api.courier.com/send \
  -H "Authorization: Bearer $COURIER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
      "message": {
        "to": {
          "user_id": "user_123"
        },
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
        "providers": {
          "slack": {
            "override": {
              "body": {
                "thread_ts": "1234567890.123456"
              }
            }
          }
        }
      }
    }'

response = courier.send_.message(
  message: {
    to: {
      user_id: "user_123"
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    providers: {
      "slack" => {
        override: {
          body: {
            thread_ts: "1234567890.123456"
          }
        }
      }
    }
  }
)

response, err := client.Send.Message(context.TODO(), courier.SendMessageParams{
	Message: courier.SendMessageParamsMessage{
		To: courier.SendMessageParamsMessageToUnion{
			OfUserRecipient: &shared.UserRecipientParam{
				UserID: courier.String("user_123"),
			},
		},
		Template: courier.String("nt_01kx4h2jdafq8bk9aftxak4b40"),
		Providers: shared.MessageProvidersParam{
			"slack": shared.MessageProvidersTypeParam{
				Override: map[string]any{
					"body": map[string]any{
						"thread_ts": "1234567890.123456",
					},
				},
			},
		},
	},
})

SendMessageParams params = SendMessageParams.builder()
    .message(SendMessageParams.Message.builder()
        .to(UserRecipient.builder().userId("user_123").build())
        .template("nt_01kx4h2jdafq8bk9aftxak4b40")
        .providers(MessageProviders.builder()
            .putAdditionalProperty("slack", JsonValue.from(java.util.Map.of(
                "override", java.util.Map.of("body", java.util.Map.of("thread_ts", "1234567890.123456")))))
            .build())
        .build())
    .build();
SendMessageResponse response = client.send().message(params);

$response = $client->send->message(
  message: [
    'to' => [
      'user_id' => 'user_123',
    ],
    'template' => "nt_01kx4h2jdafq8bk9aftxak4b40",
    'providers' => [
      'slack' => [
        'override' => [
          'body' => [
            'thread_ts' => '1234567890.123456',
          ],
        ],
      ],
    ],
  ],
);

SendMessageParams parameters = new()
{
    Message = new()
    {
        To = new UserRecipient { UserID = "user_123" },
        Template = "nt_01kx4h2jdafq8bk9aftxak4b40",
        Providers = new Dictionary<string, MessageProvidersType>()
        {
            {
                "slack",
                new()
                {
                    Override = new Dictionary<string, JsonElement>()
                    {
                        { "body", JsonSerializer.SerializeToElement(new { thread_ts = "1234567890.123456" }) },
                    },
                }
            },
        },
    },
};

var response = await client.Send.Message(parameters);

courier send message \
  --api-key "$COURIER_API_KEY" \
  --message.to '{"user_id": "user_123"}' \
  --message.template nt_01kx4h2jdafq8bk9aftxak4b40 \
  --message.providers '{"slack": {"override": {"body": {"thread_ts": "1234567890.123456"}}}}'

With Courier MCP, send my template to user_123 as a reply in an existing Slack thread.

Mentioning users

Mention a user in your message using <@USER_ID> syntax in your template:

Hello <@UEFNTF6QL>, you have a new notification!

You can also use variables for dynamic mentions.

Preventing unwanted mentions

Slack automatically parses text for @name patterns and turns them into mentions. If your message content includes text that resembles a mention but shouldn’t trigger one, set verbatim: true on the Block Kit text object to disable this parsing. Courier’s standard template blocks (text, quote, etc.) don’t expose the verbatim flag. To use it, either pass raw Block Kit JSON via providers.slack.override.body.blocks or use a in Design Studio:

{
  "type": "section",
  "text": {
    "type": "mrkdwn",
    "text": ">>> Message from @jennifer about the deployment",
    "verbatim": true
  }
}

Slash command responses

If responding to a Slash Command, use the response_url as an incoming webhook:

{
  "to": {
    "slack": {
      "incoming_webhook": {
        "url": "https://hooks.slack.com/commands/1234/5678"
      }
    }
  }
}

Set override.slack.body.response_type to in_channel or ephemeral as needed.

Incoming webhooks

You can send messages to a channel using a Slack Incoming Webhook:

{
  "to": {
    "slack": {
      "incoming_webhook": {
        "url": "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX"
      }
    }
  }
}

Updating notifications

To update a previously sent Slack message, set a “replacement key” (usually ts) in your notification template’s Slack channel settings. Courier will use this key to update the message instead of posting a new one.

Delivery tracking

When Courier sends a Slack message via Bot OAuth (chat.postMessage), it captures Slack’s ts (message timestamp identifier) and channel (conversation ID) from the API response. You can use these values to thread replies, update messages, or link back to the original Slack message.

Where delivery data appears

Slack-specific fields are returned in the providers array of the response and in webhook events:

{
  "providers": [
    {
      "provider": "slack",
      "status": "DELIVERED",
      "channel": {
        "key": "direct_message:slack",
        "name": "Slack",
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40"
      },
      "reference": {
        "channel": "C04EXAMPLE",
        "ts": "1630512468.000700"
      },
      "sent": 1630512468691,
      "delivered": 1630512468700
    }
  ]
}

Field	Description
`providers[].reference.ts`	Slack message timestamp. Use this to reply in a thread or update the message.
`providers[].reference.channel`	Slack conversation ID where the message was posted.
`providers[].channel`	Courier routing metadata (template and channel key). Not the Slack channel ID.

Slack messages are marked as DELIVERED immediately after sending because Slack’s API confirms delivery synchronously. The delivered and sent timestamps will be very close together.

Incoming Webhook sends may not include reference data because Slack’s Incoming Webhook API does not return ts or channel in its response.

Troubleshooting

Missing or incorrect Slack scopes:
- Double-check your app has all required scopes (chat:write, im:write, users:read, users:read.email, and chat:write.public for channels).
- Reinstall your Slack app after updating scopes.
Bot not invited to channel:
- Make sure your Slack app/bot is a member of the channel you want to message.
Invalid or missing tokens:
- Ensure you are using the correct Bot User OAuth Access Token (starts with xoxb-).
- Never use a user token or an expired token.
Permission errors or message not delivered:
- Check the for error details and troubleshooting tips.
User or channel not found:
- Double-check the email, user_id, or channel ID. For channels, copy the ID from the Slack URL.
Message Truncated:
- Slack blocks limit the characters in a single section to 3k characters. Courier automatically truncates Slack messages over 3k characters by removing escape and formating characters that are added by Slack after submitting the block.

If you’re still stuck, reach out to Courier support at support@courier.com.

Provider details

slack

Courier recommends routing to the channel. Naming this key in routing.channels instead is supported, and sends through just this provider.

Send to a specific provider

When that is worth doing, and what you give up: failover, channel priority, and providers you add later.

Get started

Available integrations

Send Slack messages through Courier

Prerequisites

Setup

Profile requirements

Send by user id

Send to a recipient

Overrides

Unfurl links

Slack blocks (Block Kit)

Replying in a thread

Mentioning users

Preventing unwanted mentions

Slash command responses

Incoming webhooks

Updating notifications

Delivery tracking

Where delivery data appears

Troubleshooting

Provider details

Send to a specific provider

​Prerequisites

​Setup

​Profile requirements

Send by user id

​Send to a recipient

​Overrides

​Unfurl links

​Slack blocks (Block Kit)

​Replying in a thread

​Mentioning users

​Preventing unwanted mentions

​Slash command responses

​Incoming webhooks

​Updating notifications

​Delivery tracking

​Where delivery data appears

​Troubleshooting

​Provider details

Send to a specific provider

Prerequisites

Setup

Profile requirements

Send to a recipient

Overrides

Unfurl links

Slack blocks (Block Kit)

Replying in a thread

Mentioning users

Preventing unwanted mentions

Slash command responses

Incoming webhooks

Updating notifications

Delivery tracking

Where delivery data appears

Troubleshooting

Provider details