Slack

Overview

Slack nodes allow you to interact with Slack workspaces through OAuth-connected apps. These nodes enable you to send messages, retrieve conversation histories, manage channels, and interact with users programmatically.

All Slack nodes require a Slack connection to be configured in the Connections panel. You can set up a Slack connection through the Connections panel in your Intellectible dashboard.

---

Slack:Send Message

Controlled node

Send a message to a Slack channel or thread. Supports rich formatting using Slack Block Kit.

Inputs

Input	Type	Description	Default
Run	Event	Triggers the node to execute	-
Channel ID	Text	The ID of the Slack channel to send the message to	-
Message	Text	The text content of the message to send	-
Thread Ts	Text	(Optional) Thread timestamp to reply in a thread. If provided, the message will be posted as a reply	-
Blocks	Dictionary	(Optional) Slack Block Kit blocks for rich message formatting. See Slack API documentation	-

Outputs

Output	Type	Description
Done	Event	Fires when the message has been sent successfully
Status	Data	Response status from the Slack API

Settings

Setting	Type	Description
Connections	Connection	The Slack OAuth connection to use for authentication

Example Use Case

Send a notification to a team channel when a workflow completes, or reply to a specific thread with updates.

---

Slack:List Conversations

Controlled node

Retrieve a list of conversations (channels, DMs, group DMs) from your Slack workspace.

Inputs

Input	Type	Description	Default
Run	Event	Triggers the node to execute	-
Limit	Number	Number of conversations to retrieve per page (max 200)	200
Max Pages	Number	Maximum number of pages to fetch (max 5 for up to 1000 conversations total)	5
Cursor	Text	(Optional) Pagination cursor to fetch the next set of results. See pagination guide for retrieving more than 1000 conversations	-

Outputs

Output	Type	Description
Done	Event	Fires when the conversations have been retrieved
Conversations	Data	List of conversation objects containing channel information

Settings

Setting	Type	Description
Connections	Connection	The Slack OAuth connection to use for authentication

Example Use Case

List all channels in a workspace to display available options to users, or to find specific channels by name.

---

Slack:Get Conversation History

Controlled node

Fetch the message history from a specific Slack channel or conversation.

Inputs

Input	Type	Description	Default
Run	Event	Triggers the node to execute	-
Channel ID	Text	The ID of the Slack channel to retrieve history from	-
Limit	Number	Number of messages to retrieve per page (max 200)	200
Max Pages	Number	Maximum number of pages to fetch (max 5 for up to 1000 messages total). Defaults to 5 if not specified	-
Cursor	Text	(Optional) Pagination cursor to fetch the next set of results. See pagination guide for retrieving more than 1000 messages	-

Outputs

Output	Type	Description
Done	Event	Fires when the message history has been retrieved
Messages	Data	List of message objects from the conversation

Settings

Setting	Type	Description
Connections	Connection	The Slack OAuth connection to use for authentication

Example Use Case

Retrieve recent messages from a support channel to analyze customer issues, or fetch conversation context for AI processing.

---

Slack:Get User Info

Controlled node

Retrieve detailed information about a specific Slack user.

Inputs

Input	Type	Description	Default
Run	Event	Triggers the node to execute	-
User ID	Text	The Slack user ID to retrieve information for	-

Outputs

Output	Type	Description
Done	Event	Fires when the user information has been retrieved
User Info	Data	Object containing user details (name, email, profile, timezone, etc.)

Settings

Setting	Type	Description
Connections	Connection	The Slack OAuth connection to use for authentication

Example Use Case

Look up user details to personalize messages, or retrieve user contact information for notifications.

---

Slack:Join Channel

Controlled node

Join a Slack channel with your bot user. The bot must have permission to join the specified channel.

Inputs

Input	Type	Description	Default
Run	Event	Triggers the node to execute	-
Channel ID	Text	The ID of the Slack channel to join	-

Outputs

Output	Type	Description
Done	Event	Fires when the channel has been joined successfully
Status	Data	Response status from the Slack API

Settings

Setting	Type	Description
Connections	Connection	The Slack OAuth connection to use for authentication

Example Use Case

Automatically join new channels created in your workspace, or join a channel before sending messages to it.

---

Slack:Open Conversation

Controlled node

Open a direct message or multi-person direct message conversation with one or more users.

Inputs

Input	Type	Description	Default
Run	Event	Triggers the node to execute	-
Users	Text	User ID(s) to open a conversation with. Can be a single user ID, comma-separated string of user IDs, or an array of user IDs	-
Return Im	Boolean	(Optional) If true, returns existing IM channel if available	-

Outputs

Output	Type	Description
Done	Event	Fires when the conversation has been opened
Conversation	Data	Object containing the conversation/channel information

Settings

Setting	Type	Description
Connections	Connection	The Slack OAuth connection to use for authentication

Example Use Case

Open a DM with a user to send them a private notification, or create a group DM for team collaboration.

---

Setting Up Slack Connections

To use Slack nodes, you need to create a custom Slack app and configure it with the appropriate OAuth scopes and credentials.

• Creating a new app at api.slack.com/apps
• Configuring OAuth & Permissions with refresh tokens
• Adding redirect URLs for Intellectible
• Setting up the required Bot Token Scopes (e.g., chat:write, channels:read, users:read)
• Getting your Client ID and Client Secret
• Adding the connection in Intellectible

For complete step-by-step instructions on creating and configuring your Slack app, see the Creating a Slack App section in the Connections Guide.

Using the Connection in Workflows

Once you've set up your Slack connection:

1. Navigate to the Connections section in your Intellectible dashboard
2. Verify your Slack connection is active
3. Add the connection to the projects that need it via Manage Projects
4. In your workflow, select the connection in each Slack node's Connections panel

---

Common Patterns

Sending Notifications

Connect the Done output of your workflow nodes to a Slack: Send Message node to send notifications when tasks complete.

Processing Channel Messages

Use Slack: Get Conversation History to retrieve messages, then pipe them through AI nodes for analysis, summarization, or classification.

Bot Interactions

Combine Slack: Open Conversation and Slack: Send Message to create interactive bot workflows that respond to user actions.

---

Cursor Pagination for More Than 1000 Results

When you need to retrieve more than 1000 messages or conversations from Slack, you can use cursor-based pagination with the While node. This pattern allows you to continuously fetch data until all results have been retrieved.

Overview

The Slack: Get Conversation History and Slack: List Conversations nodes support cursor-based pagination. By default, they retrieve up to 1000 results (5 pages × 200 per page). To fetch more, you'll need to:

1. Initialize a cursor variable
2. Use a While node to loop while the cursor is not null
3. Pass the cursor to subsequent API calls
4. Update the cursor with each response
5. The loop automatically breaks when the cursor becomes null

Step-by-Step Implementation

1. Find Your Channel ID

First, use Slack: List Conversations to find the conversation ID of the channel you want to retrieve history from:

• Connect the List Conversations node to your workflow start
• The output will contain a list of conversations with their IDs
• Note the id field of the conversation you want to retrieve

2. Initialize the Cursor Variable

At the start of your workflow, create a Variable node to store the cursor:

• Add a Variable node
• Set the variable name to cursor
• Set the initial value to empty (leave blank or use empty string "")

This empty cursor tells the Slack API to start from the beginning.

3. Set Up the While Node

Add a While node configured to run while the cursor is valid:

• Add a While node after your start
• Set Variable Name to cursor
• In the node's properties panel:
  • Set Operation to !=
  • Set Break Value to null
• This will continue looping as long as cursor != null

While Condition

The loop will automatically break when the cursor becomes null, indicating no more results are available.

4. Pass the Cursor to Get Conversation History

Inside the loop, connect a Slack: Get Conversation History node:

• Set Channel ID to the channel you want to retrieve
• Set Limit to 200 (maximum per page)
• Set Max Pages to 1 (we'll handle pagination manually with the loop)
• Connect the Cursor input to your cursor variable using {{cursor}}

5. Store Messages with Index Key

After each API call, store the messages using a Set Variable node:

• Add a Set Variable node after the Get Conversation History node
• Set the variable name to messageHistory/{{index}}
  • The {{index}} comes from the While node's current iteration index
  • This creates a unique key for each batch of messages (e.g., messageHistory/0, messageHistory/1, etc.)
• Set the value to the messages output from the Get Conversation History node

6. Update the Cursor

Add another Set Variable node to update the cursor for the next iteration:

• Add a Set Variable node
• Set the variable name to cursor
• Set the value to {{messages.nextCursor}}
  • This extracts the nextCursor field from the response
  • When there are no more results, this will be null, breaking the loop

7. Flatten the Results

After the loop completes, use a Flatten List node to combine all message batches:

• Connect a Flatten List node to the While node's Finished output
• Pass the messageHistory variable (which now contains all batches)
• The output will be a single flat array containing all messages from all iterations

Complete Workflow Structure

[Start]
  ↓
[Set Variable: cursor = ""]
  ↓
[While: cursor != null]
  ↓
  [Get Conversation History]
    - channelId: "C1234567890"
    - cursor: {{cursor}}
    - limit: 200
    - maxPages: 1
  ↓
  [Set Variable: messageHistory/{{index}} = messages]
  ↓
  [Set Variable: cursor = messages.nextCursor]
  ↓ (loop continues while cursor != null)
[While Finished]
  ↓
[Flatten List: messageHistory]
  ↓
[All messages retrieved!]

Key Points

• Cursor starts empty: An empty cursor tells the API to start from the beginning
• While loop breaks automatically: When nextCursor is null, the While node's condition (cursor != null) becomes false and iteration stops
• Unique keys: Using {{index}} from the While node ensures each batch is stored separately
• Flatten at the end: The Flatten List node combines all batches into a single array for easy processing

This pattern works for both Get Conversation History and List Conversations nodes when you need to retrieve more than 1000 results.

---

Slack:Send Message

Controlled node

Overview

Sends a message to a Slack channel, private channel, or direct message conversation. This node supports both plain text messages and rich formatting using Slack's Block Kit UI framework. You can also reply to existing messages by providing a thread timestamp.

To use this node, you must have a Slack connection configured in your project with appropriate permissions (typically chat:write and chat:write.public scopes).

Inputs

Input	Type	Description	Default
Run	Event	Triggers the node to send the message to Slack.	-
Channel ID	Text	The Slack channel ID (e.g., C1234567890) or conversation ID to send the message to.	-
Message	Text	The plain text message content. Required if Blocks is not provided.	-
Thread Ts	Text	Optional thread timestamp (e.g., 1234567890.123456) to reply in a specific thread.	-
Blocks	Dictionary	Optional Slack Block Kit blocks for rich formatting. Must be a valid JSON object or array. Required if Message is not provided.	-
Connections	Connection	The Slack connection to use for authentication. Configure this in the properties panel.	-

Outputs

Output	Type	Description
Done	Event	Fires when the message has been sent or if an error occurs.
Status	Data	Returns "success" if the message was sent successfully, or an error object with a message if the operation failed.

Runtime Behavior and Defaults

The node validates inputs before sending:

• Either Message or Blocks must be provided (but not necessarily both).
• If Blocks is provided, it must be a valid JSON object or array conforming to Slack's Block Kit format.
• The Channel ID must be a valid Slack channel or conversation ID.
• If Thread Ts is provided, the message will be posted as a reply in that thread.

On success, the Status output will contain "success". On failure, it will contain an error object with details about what went wrong (e.g., missing connection, invalid channel, or API errors).

Example Usage

Sending a simple text message:

1. Connect a Start node or button event to the Run input.
2. Set Channel ID to a Slack channel ID (e.g., "C1234567890").
3. Set Message to "Hello from Intellectible!".
4. Select your Slack connection in the Connections property.
5. When triggered, the message will be posted to the channel.

Replying in a thread:

1. Use the Slack: Get Conversation History node to retrieve messages and their timestamps.
2. Extract the ts field from a message (e.g., "1234567890.123456").
3. Pass this value to the Thread Ts input of the Send Message node.
4. The new message will appear as a reply in that thread.

Using Block Kit for rich formatting:

1. Instead of using the Message input, provide a Blocks dictionary containing Slack Block Kit JSON:

   [
     {
       "type": "section",
       "text": {
         "type": "mrkdwn",
         "text": "Hello, *world*!"
       }
     }
   ]
2. This will render formatted content in Slack rather than plain text.

---

Slack:List Conversations

Controlled node

Overview

Retrieves a list of Slack conversations (channels, direct messages, and group messages) accessible to the connected Slack workspace. This node supports pagination to handle large numbers of conversations, allowing you to retrieve up to 1,000 conversations per workflow run.

The node queries the Slack API for conversation types including public channels, private channels, instant messages (IM), and multi-party instant messages (MPIM).

Pagination

Slack API limits results to 200 conversations per request. This node automatically handles pagination up to 5 pages (1,000 total conversations). To retrieve additional conversations beyond 1,000, use the cursor output from the result and feed it back into the cursor input for subsequent calls.

Inputs

Input	Type	Description	Default
Run	Event	Triggers the node to fetch conversations from Slack.	-
Limit	Number	The maximum number of conversations to return per page (max 200).	200
Max Pages	Number	The maximum number of pages to fetch (max 5). Each page retrieves up to limit conversations.	5
Cursor	Text	Pagination cursor from a previous call. Leave empty for the first request; provide the cursor from previous results to fetch the next set of conversations.	-
Connections	Connection	The Slack workspace connection to use. Must be configured in the project connections.	-

Outputs

Output	Type	Description
Done	Event	Fires when the node has finished fetching conversations.
Conversations	Data	An array of conversation objects containing channel IDs, names, types, and metadata. Returns an error object if the request fails.

Runtime Behavior and Defaults

When triggered, the node validates that:

• A valid Slack connection is selected
• The limit does not exceed 200 (enforced maximum)
• The maxPages does not exceed 5 (enforced maximum)

If validation passes, the node calls the Slack API to fetch conversations of types: public_channel, private_channel, im, and mpim. It automatically paginates through up to maxPages pages, combining results into a single output array.

The node returns up to 1,000 conversations total (200 limit × 5 pages). If more conversations exist, the last page's result will include a next_cursor in the response metadata, which can be extracted and passed to the cursor input of a subsequent node call to continue pagination.

Example Usage

Basic Conversation Listing

Connect a Start node to the Run input of Slack List Conversations. Set the Limit to 100 and Max Pages to 2 to retrieve up to 200 recent conversations. Connect the Conversations output to a processing node to iterate through the results.

Paginated Retrieval

To retrieve more than 1,000 conversations or implement pagination:

1. First call: Leave Cursor empty, set Max Pages to 5
2. Extract the next_cursor from the Conversations output (typically found in response_metadata.next_cursor)
3. Feed this cursor value into the Cursor input of a subsequent Slack List Conversations node
4. Repeat until no cursor is returned (all conversations fetched)

// Example output structure (conversations array):
[
  {
    "id": "C1234567890",
    "name": "general",
    "is_channel": true,
    "is_private": false,
    "created": 1360782804,
    "creator": "U1234567890"
  },
  // ... more conversations
]

---

Slack:Get Conversation History

Controlled node

Overview

Retrieves the message history from a Slack channel or conversation. This node fetches messages in batches (pages) and supports pagination to retrieve up to 1000 messages per execution.

The node requires a Slack connection to be configured in the project settings. It will fetch up to 200 messages per page and can retrieve a maximum of 5 pages (1000 messages total) in a single run. For larger histories, use the cursor output to paginate through results.

Inputs

Input	Type	Description	Default
Run	Event	Triggers the node to fetch conversation history	-
Channel ID	Text	The Slack channel ID or conversation ID to fetch history from	-
Limit	Number	Maximum number of messages to fetch per page (max 200)	200
Max Pages	Number	Maximum number of pages to fetch (max 5, totaling 1000 messages)	1
Cursor	Text	Pagination cursor for fetching subsequent pages of history	-
Connections	Connection	Slack connection to use for the API call	-

Outputs

Output	Type	Description
Done	Event	Fires when the node has finished fetching messages
Messages	Data	Array of message objects from the conversation history, or an error object if the request failed

Runtime Behavior and Defaults

• Controlled Node: This node requires a Run event to execute. It will not run automatically when data changes.
• Pagination: The node supports Slack's cursor-based pagination. Pass the cursor from a previous run into the Cursor input to fetch the next page of results.
• Rate Limiting: The node respects Slack's rate limits by fetching pages sequentially with a small delay between requests.
• Error Handling: If the Slack API returns an error (e.g., invalid channel ID, missing permissions), the Messages output will contain an error object with details rather than the message array.
• Maximum Results: While the Limit input accepts values up to 200, and Max Pages accepts values up to 5, exceeding these limits will result in an error output.

Example Usage

Basic Channel History Retrieval:

1. Connect a Start node or event trigger to the Run input
2. Provide a Slack channel ID (e.g., C1234567890) to the Channel ID input
3. Set Limit to 100 to fetch 100 messages per page
4. Set Max Pages to 2 to fetch up to 200 messages total
5. Connect the Done event to trigger downstream processing
6. Access the message history from the Messages output, which will contain an array of Slack message objects

Paginated History Retrieval:

1. First run: Leave Cursor empty to fetch the first page
2. Store the returned messages and check if more pages exist (the Slack API returns a response_metadata.next_cursor in the result)
3. Subsequent runs: Pass the next_cursor value into the Cursor input to fetch the next page
4. Repeat until no more cursor is returned or you've reached your desired message count

---

Slack:Get User Info

Controlled node

Overview

Retrieves detailed information about a specific Slack user using the Slack Web API. This node requires a configured Slack connection and a valid user ID to fetch profile data including name, email, timezone, and status information.

Slack Connection Required

This node requires a Slack connection to be configured in your project settings. Use the Connections property panel to select a pre-configured Slack workspace connection.

Inputs

Input	Type	Description	Default
Run	Event	Triggers the node to fetch user information.	-
User ID	Text	The Slack user ID (e.g., U1234567890) of the user to look up.	-
Connections	Connection	The Slack workspace connection to use (configured in properties panel).	-

Outputs

Output	Type	Description
Done	Event	Fires when the user information has been successfully retrieved.
User Info	Data	An object containing the Slack user's profile information including id, name, real_name, email, tz (timezone), status, and other profile fields. Returns an error object if the request fails.

Runtime Behavior

When triggered by the Run event, this node makes an authenticated request to the Slack Web API using the configured connection. It validates that:

1. A project ID is available (inherited from the workflow runtime)
2. A Slack connection is selected
3. A valid userId is provided

If any validation fails, the node outputs an error object via the User Info output and does not fire the Done event.

On success, the User Info output contains the full Slack user profile as returned by the users.info Slack API method, and the Done event fires to trigger downstream nodes.

Example Usage

Basic User Lookup:

1. Connect a Text node or Plain Text node to the User ID input with a Slack user ID (e.g., U1234567890)
2. Configure the Connections property in the panel UI to select your Slack workspace
3. Trigger the Run input with an event (e.g., from a Start node or button click)
4. Connect the User Info output to a Show node to display the user's profile, or use Get Value to extract specific fields like email or real_name

Error Handling: Connect the User Info output to an If node to check for errors before processing:

• Condition: userInfo.error is not null
• True branch: Handle error (e.g., show "User not found" message)
• False branch: Process user data (e.g., userInfo.real_name)

---

Slack:Join Channel

Controlled node

Overview

Joins a Slack channel using a configured Slack connection. The bot user associated with the connection must have permission to join the target channel. This node is useful for programmatically joining channels in workflows that need to post messages or monitor specific channels.

Inputs

Input	Type	Description	Default
Run	Event	Fires when the node starts running	-
Channel ID	Text	The ID of the Slack channel to join (e.g., "C1234567890")	-

Outputs

Output	Type	Description
Done	Event	Fires when the node has finished
Status	Data	Returns "success" if the channel was joined successfully, or an error object with details if the operation failed

Properties

Property	Type	Description	Default
Connections	Connection	The Slack connection to use for this operation. Configure Slack connections in your project settings.	-

Runtime Behavior and Defaults

This node requires a valid Slack connection to be selected in the properties panel before it can execute. The bot user associated with the selected connection must have the necessary permissions to join channels in your Slack workspace.

When triggered:

1. Validates that a Slack connection is configured
2. Validates that a Channel ID is provided
3. Attempts to join the specified channel using the Slack API
4. Returns "success" in the Status output if successful, or an error object if the join operation fails (e.g., if the bot lacks permissions or the channel doesn't exist)

Note: The Channel ID is different from the channel name. Channel IDs typically start with "C" for public channels or "G" for private channels/groups.

Example Usage

Basic Channel Join

1. Connect a Start node or any event-emitting node to the Run input
2. Enter the Channel ID (e.g., "C1234567890") in the Channel ID field, or connect a Text node providing the channel ID
3. Select your Slack connection in the Connections property panel
4. Connect the Done event to subsequent nodes that should run after joining the channel
5. Optionally, connect the Status output to a condition check or logging node to verify the join was successful

Error Handling

To handle cases where the join might fail (e.g., the bot is already in the channel or lacks permissions):

• Connect the Status output to an If node
• Check if Status equals "success"
• If false, handle the error appropriately (e.g., log the error or notify the user)

---

Slack:Open Conversation

Controlled node

Overview

Opens a direct message (DM) or multi-person direct message conversation in Slack. This node creates or retrieves an existing conversation channel with specified users, returning the conversation metadata (including the channel ID) needed to send messages to that channel.

Slack Connection Required

This node requires a Slack connection to be configured in your project settings. The connection must have appropriate permissions to open conversations with the specified users.

Inputs

Input	Type	Description	Default
Run	Event	Triggers the node to open the conversation	-
Users	Text	User IDs to open the conversation with. Can be provided as a comma-separated string (e.g., "U1234567890,U0987654321") or an array of user IDs	-
Return IM	Boolean	If true, returns IM (direct message) channel information. Useful when working with direct message channels specifically	false
Connections	Connection	Slack connection configuration for authentication	-

Outputs

Output	Type	Description
Done	Event	Fires when the conversation has been successfully opened or retrieved
Conversation	Data	The conversation object containing channel ID and other metadata. Returns an error object if the operation fails

Runtime Behavior and Defaults

When triggered, the node attempts to open or retrieve a conversation with the specified users using the Slack API. If a conversation already exists with those users, it returns the existing channel; otherwise, it creates a new one.

• Users Input: Accepts either a single user ID for a direct message, or multiple user IDs for a multi-person direct message (MPDM)
• Error Handling: If the connection is missing, project ID is unavailable, or users are not provided, the node returns an error object in the Conversation output
• Permissions: The Slack bot must have appropriate scopes (including chat:write and im:write) to open conversations

Example Usage

Scenario: Starting a direct message with a specific user when a button is clicked.

1. Connect a Start node or Form Event node to the Run input
2. Set the Users input to a Slack user ID (e.g., "U1234567890") or connect a variable containing the user ID
3. Select your Slack Connection in the properties panel
4. Connect the Conversation output to a Slack: Send Message node's Channel ID input
5. Connect the Done event to trigger the message sending

Tip: To open a conversation with multiple users, provide a comma-separated list of user IDs like "U1234567890,U0987654321,U1122334455".