ArcIntegrate | The B2B SaaS Interoperability Engine

Overview: Connecting Slack and Trello

The Slack-to-Trello integration serves teams that use Slack as their primary communication hub but rely on Trello for visual project and task management. The central operational challenge this integration solves is task capture latency: valuable action items and decisions that surface during Slack conversations are frequently lost unless someone manually translates them into Trello cards. By the time a team member switches context to Trello, the original message has scrolled off the screen, the conversation has moved on, and the task details require reconstruction from memory. This integration eliminates that friction by enabling card creation directly from Slack through emoji reactions, slash commands, or automated message-matching rules—without requiring the user to leave the conversation.

In a typical enterprise setting, the workflow operates as follows. During a client call debrief in a Slack channel, a project manager reacts to a specific action item message with a designated emoji such as :white_check_mark:. The integration picks up the reaction_added event, creates a Trello card in the team's designated board and list, copies the message text into the card description with a permalink back to the original Slack thread, and posts a confirmation reply in the thread containing the new Trello card URL. If the original message mentioned a team member by Slack handle, the integration resolves that handle to an email address and assigns the card to the matching Trello member. This creates a seamless loop between conversational task identification in Slack and structured task management in Trello without any manual context switching required.

Core Prerequisites

For Slack, create a Slack App in the App Management portal at api.slack.com/apps. The app requires the following Bot Token OAuth scopes: channels:history (to read messages in public channels after a reaction event), groups:history (to read messages in private channels), reactions:read (to receive reaction_added workspace events via the Events API), chat:write (to post card confirmation messages back to threads), commands (to register and handle slash commands), users:read (to look up Slack user IDs and display names), and users:read.email (to resolve Slack user email addresses for Trello member assignment). For reaction-based triggers, you must enable the Events API in the app configuration, set your event endpoint URL, and subscribe to the reaction_added workspace event. When you save the event subscription URL, Slack will immediately send a POST request containing a challenge field, and your server must respond with 200 OK and the raw challenge string value to complete the verification handshake.

For Trello, generate an API Key from trello.com/app-key while logged into the account that will own the integration. Generate a User Token by directing each user through the Trello authorization URL: https://trello.com/1/authorize?expiration=never&scope=read,write&response_type=token&key={api_key}. The scope=read,write combination grants permission to read board and list structures and to create and update cards. Note that Trello uses API Key and Token as query string parameters rather than a Bearer token in the Authorization header—this is a common implementation mistake that produces 401 Unauthorized errors when developers mistakenly attempt Authorization: Bearer {token} syntax. The correct format appends ?key={api_key}&token={user_token} to all API request URLs or passes them as JSON body fields for POST requests.

Top Enterprise Use Cases

The primary use case is emoji reaction-triggered card creation. Teams establish a dedicated emoji convention (for example, :card_index_dividers: for tasks, :bug: for defect reports, :bulb: for ideas to capture) and the integration creates Trello cards in board-specific lists based on which emoji was added. The card title is derived from the first 60 characters of the Slack message text. The card description includes the channel name, the message timestamp formatted as a human-readable date, the full message text, and the permalink URL so team members can navigate back to the original discussion context directly from the Trello card.

The second high-value use case is slash command-driven structured card creation. A custom Slack slash command such as /card or /trello allows users to create Trello cards directly from the Slack message input box with structured arguments parsed from the command text. For example, a user could type /card "Fix authentication redirect loop" board:backend list:"In Progress" @alice due:2025-11-07 and the integration would create a card with the specified title on the backend board, placed in the "In Progress" list, assigned to Alice, and with a due date of November 7th. The slash command payload from Slack arrives as an HTTP POST to your registered command URL with form-encoded parameters including text, user_id, channel_id, and team_id.

A third use case is daily standup aggregation into Trello. A scheduled trigger running each morning reads the last 24 hours of messages in a designated standup Slack channel and creates a summary Trello card in a "Daily Standups" archive list. Each team member's most recent message in the channel is included in the card description under their display name, providing a persistent, searchable record of team status outside of Slack's message retention window.

Step-by-Step Implementation Guide

The core architecture for reaction-based triggers relies on the Slack Events API. When a user adds a reaction to a message, Slack delivers a POST request to your registered event subscription endpoint containing a payload with the following structure:

{
  "type": "event_callback",
  "event": {
    "type": "reaction_added",
    "user": "U024BE7LH",
    "reaction": "white_check_mark",
    "item": {
      "type": "message",
      "channel": "C0G9QF9GZ",
      "ts": "1360782400.498405"
    },
    "item_user": "U0G9QF9G8",
    "event_ts": "1360782804.083113"
  },
  "team_id": "T0G9QF9GZ",
  "event_id": "Ev09RD8T46"
}

Your integration server must validate the X-Slack-Signature header on every incoming request using HMAC-SHA256 with your app's Signing Secret before processing any event data. The signature is computed as hmac_sha256(signing_secret, "v1:" + request_timestamp + ":" + raw_body_string). Critically, the HMAC must be computed against the raw, unparsed request body bytes—if your web framework's JSON body parser middleware runs before your signature validation code, the raw bytes may differ from what Slack signed, causing persistent signature mismatch errors.

After validating the signature, check whether the reaction field matches your configured trigger emoji. If it matches, make a conversations.history call to retrieve the original message text:

curl -X GET "https://slack.com/api/conversations.history?channel=C0G9QF9GZ&latest=1360782400.498405&limit=1&inclusive=true" \
  -H "Authorization: Bearer xoxb-your-bot-token"

Extract the text field from the message, then construct and POST a new card to the Trello API. The card creation endpoint accepts JSON in the request body:

curl -X POST "https://api.trello.com/1/cards" \
  -H "Content-Type: application/json" \
  -d "{
    \"name\": \"[Slack Task] Fix authentication redirect loop\",
    \"desc\": \"**Source Channel:** #engineering\\n**Posted by:** Alice Chen\\n**Original Message:** https://yourworkspace.slack.com/archives/C0G9QF9GZ/p1360782400498405\\n\\nFull message text captured here.\",
    \"idList\": \"507f1f77bcf86cd799439011\",
    \"due\": null,
    \"key\": \"{trello_api_key}\",
    \"token\": \"{trello_user_token}\"
  }"

The idList value is the Trello list ID where the card should be created. Retrieve available list IDs by calling GET https://api.trello.com/1/boards/{boardId}/lists?key={key}&token={token} and store them in your integration's configuration layer. Once the card is created, the response body contains the new card's shortUrl property. Post a reply to the original Slack thread by calling chat.postMessage with the thread_ts field set to the original message timestamp value:

{
  "channel": "C0G9QF9GZ",
  "thread_ts": "1360782400.498405",
  "text": ":white_check_mark: Trello card created: https://trello.com/c/AbCdEf12"
}

In Make, configure a Webhooks > Custom Webhook module as the scenario trigger and set the Make-generated webhook URL as the event subscription endpoint in the Slack App configuration. The incoming Slack event body is automatically parsed, exposing the event.reaction, event.item.channel, and event.item.ts fields as mappable variables. Add a Slack > Get a Message module using the channel and timestamp values to retrieve the original message text. Add a Trello > Create a Card module with the idList field set to the board's target list ID, the name field mapped from the Slack message text (truncated with a Text Parser module if needed), and the desc field composed with the channel permalink and original message content. Finally, add a Slack > Create a Message module with thread_ts populated to post the Trello card URL back to the original message thread.

In Zapier, use the Slack > New Reaction Added trigger, which requires the app to have reactions:read scope and the Events API enabled. Add a Filter by Zapier step to check that the Reaction field equals your chosen emoji name (without surrounding colons—Zapier normalises this field). Then add the Trello > Create Card action, mapping the Slack message text to the Name field and the channel permalink to the Description field. For the follow-up Slack reply, add a second Slack > Send Channel Message action with the Thread Timestamp field populated from the trigger step's Message Timestamp value.

Common Pitfalls & Troubleshooting

A 403 Forbidden from the Slack Web API with an error body containing {"ok": false, "error": "missing_scope"} indicates the bot token does not have a required OAuth scope. Each Slack API method documents its required scope in the API documentation. Add the missing scope in the Slack App configuration under OAuth & Permissions > Bot Token Scopes and reinstall the app to the workspace to generate a new token with the updated scopes. An invalid_auth error code indicates the token itself is invalid or has been revoked—reinstall the app to regenerate it.

A 401 Unauthorized from the Trello API with response body invalid key indicates the key parameter is malformed or belongs to a different Trello account than the token parameter. Verify that the API key and user token were generated by the same Trello account. A 404 Not Found when creating a card means the idList value references a list that does not exist or that the authenticated user does not have access to. Validate list IDs by calling the boards endpoint before storing them in your configuration.

A 429 Too Many Requests from Trello means the rate limit of approximately 300 requests per 10 seconds per token has been exceeded. In high-volume Slack environments where many reaction events fire simultaneously (such as during a meeting where multiple team members are reacting to messages), queue card creation requests in a database table and process them with a rate-limited background worker rather than processing them synchronously in the webhook handler. On the Slack side, if your integration sends more than the per-method rate limit allows (Tier 3 methods like chat.postMessage allow approximately 50 calls per minute), you will receive a 429 with a Retry-After header and a JSON body containing {"ok": false, "error": "ratelimited"}.