Connect Trello with Slack

Overview: Connecting Trello and Slack

Trello and Slack serve complementary roles in the engineering and product management workflow. Trello provides a visual Kanban board for tracking work items — cards move through lists that represent workflow stages (e.g., Backlog, In Progress, In Review, Done). Slack provides the real-time messaging layer where decisions are made and blockers are surfaced. Without an integration between these two tools, team members must manually check Trello for status changes, creating asynchronous communication delays that slow down sprint cycles, cause missed deadlines, and fragment project visibility across toolsets.

The Trello-to-Slack integration delivers automated, contextual notifications to the right Slack channel or person at the right moment. A card moving to "In Review" can ping the reviewer in Slack. A card whose due date is tomorrow and is still in "In Progress" can send a DM to the assignee. A daily digest of all cards due within 48 hours can be posted to the team channel every morning. These are not simple webhook-to-message pipes — enterprise implementations require conditional routing, deduplication, rate limiting, and rich message formatting that makes Slack notifications immediately actionable without requiring the recipient to open Trello. This guide covers the full implementation using Trello's native Power-Ups, the Trello REST API webhooks, Make (Integromat), and Zapier.

Core Prerequisites

On the Trello side, you need a Trello account with at least Member-level access to the boards you want to monitor. To create webhooks via the Trello REST API, you need a Trello API Key and a Token. The API Key is tied to your Trello account and is obtained from https://trello.com/app-key. The Token grants access to your boards and is generated via the OAuth 1.0a flow at https://trello.com/1/authorize. For server-side webhook registration, the token must have read scope at minimum; write scope is required if your integration will also modify cards. The token does not expire by default but can be revoked. There is no OAuth 2.0 flow for Trello's API; it uses a legacy OAuth 1.0a token that acts as a long-lived bearer credential.

On the Slack side, you need a Slack workspace where you have the apps:manage permission or are a Workspace Admin. For simple integrations using Incoming Webhooks, you need a Slack app with an Incoming Webhook URL configured for the target channel. For advanced integrations (threaded replies, DMs, interactive buttons), you need a Slack app with a Bot Token (xoxb-) that has the following scopes: chat:write, chat:write.public, im:write, channels:read, users:read, and users:read.email. The users:read.email scope is required to resolve a Trello member's email address to a Slack User ID for DM delivery.

Top Enterprise Use Cases

The primary use case is real-time list transition notifications. When a card is moved to a specific list (e.g., "Needs QA" or "Blocked"), a Slack message is sent to the relevant channel. For a QA team, this replaces the need to check Trello for new work items — the work comes to them. The notification includes the card name, a direct link to the card, the name of the person who moved it, and any checklist completion status.

The second use case is assignee notifications via direct message. When a member is assigned to a Trello card, they receive a Slack DM rather than only a Trello notification (which is often ignored). This is particularly valuable for distributed teams where Trello email notifications are filtered into low-priority folders. The DM includes the card title, the list it's currently in, the due date if set, and a deep link to the card.

The third use case is a scheduled daily standup digest. Every morning at 9:00 AM in the team's timezone, a Slack message is posted to the team channel listing all cards that are due within the next 48 hours, grouped by assignee. This replaces the manual standup process of verbally reporting status by making the information available before the meeting starts.

Step-by-Step Implementation Guide

The most flexible implementation for enterprise teams is using Make (Integromat) with Trello webhooks. Begin by creating a new Scenario in Make with a Trello module as the trigger.

For real-time card movement notifications, use the Make module "Trello > Watch Events." Connect your Trello account, select the target Board, and set the Event Type to "updateCard." This module uses Trello's REST API webhook under the hood — Make registers a webhook at https://api.trello.com/1/webhooks pointing to Make's own ingestion endpoint, so you do not need to manage webhook registration manually.

The output of the "Watch Events" trigger includes the full action object. For a card move event, the relevant fields are data.card.name, data.card.id, data.card.shortLink, data.listAfter.name (the destination list), data.listBefore.name (the source list), and memberCreator.fullName (the person who performed the action). Add a filter after the trigger module to only continue execution when data.listAfter.name equals your target list name (e.g., "Needs QA").

Next, add a "Slack > Create a Message" module. Configure the channel to your target Slack channel ID. Use Block Kit formatting for rich messages by switching the message content type to "Blocks" and providing the following JSON:

[
  {
    "type": "section",
    "text": {
      "type": "mrkdwn",
      "text": "📋 *Card ready for QA:* <https://trello.com/c/{{data.card.shortLink}}|{{data.card.name}}>"
    }
  },
  {
    "type": "context",
    "elements": [
      {
        "type": "mrkdwn",
        "text": "Moved by *{{memberCreator.fullName}}* from *{{data.listBefore.name}}* → *{{data.listAfter.name}}*"
      }
    ]
  },
  {
    "type": "actions",
    "elements": [
      {
        "type": "button",
        "text": { "type": "plain_text", "text": "Open Card" },
        "url": "https://trello.com/c/{{data.card.shortLink}}"
      }
    ]
  }
]

For the assignee DM workflow, after the "Watch Events" trigger (this time filtering for type = addMemberToCard), add a "Trello > Get a Member" module to fetch the full member object using data.member.id. The member object includes the email field. Then add a "Slack > Search for User by Email" module using that email to resolve the Slack User ID. Finally, add a "Slack > Create a Message" module with the channel field set to the resolved User ID — posting to a User ID creates a DM from the Slack bot to that user.

For the daily digest using Zapier, create a Zap with a "Schedule by Zapier" trigger set to run daily at 9:00 AM. Use a "Code by Zapier" action with JavaScript to call the Trello REST API directly and fetch all cards due within 48 hours. The API endpoint is GET https://api.trello.com/1/boards/{boardId}/cards?key={apiKey}&token={token}&filter=open. Filter the returned cards in JavaScript where card.due is not null and new Date(card.due) <= new Date(Date.now() + 48 * 60 * 60 * 1000). Format the filtered cards into a Slack Block Kit message and use the "Slack > Send Channel Message" Zapier action to post the digest.

For direct Trello webhook registration without an iPaaS tool (for custom backend implementations), register a webhook by sending a POST request to the Trello API:

curl -X POST "https://api.trello.com/1/webhooks" \
  -H "Content-Type: application/json" \
  -d '{
    "callbackURL": "https://your-service.com/webhooks/trello",
    "idModel": "YOUR_BOARD_ID",
    "description": "Board activity to Slack",
    "key": "YOUR_API_KEY",
    "token": "YOUR_TOKEN"
  }'

Trello will send a HEAD request to your callbackURL to verify it is reachable before activating the webhook. Your endpoint must respond to HEAD requests with a 200 OK status. Subsequent event payloads arrive as POST requests with a JSON body containing the full action object.

Common Pitfalls & Troubleshooting

A 401 Unauthorized from the Trello API means the API Key and Token combination is invalid or the token has been revoked. Trello tokens can be revoked by the user at https://trello.com/my/account under the "Applications" section. If a team member who generated the integration token leaves the organization and their account is deactivated, all webhooks using that token will fail with 401. Always use a dedicated service account or a shared team Trello account for token generation to avoid this single point of failure.

A 429 Too Many Requests from the Trello API is enforced at 100 API requests per 10 seconds per API key, and 300 per 10 seconds per token. High-volume boards with many simultaneous card updates can breach these limits. Implement a queue in your webhook handler that batches Trello API calls and spaces them out using a token bucket algorithm. In Make, reduce the scenario execution frequency and use the "Watch Events" trigger rather than polling to minimize unnecessary API calls.

If Trello webhooks stop delivering events after working correctly for a period, the most common cause is that the webhook was automatically deactivated by Trello due to repeated delivery failures (Trello deactivates webhooks after 5 consecutive failed deliveries). This happens when your callback URL returns a non-2xx HTTP status code or is unreachable. Check your webhook's active status via GET https://api.trello.com/1/webhooks/{webhookId}?key={key}&token={token} and look at the active field. Re-activate it with a PATCH request setting active: true. Investigate the root cause of the delivery failures in your application logs before reactivating.

If Slack DMs are not being delivered even though the Slack API call returns 200 OK, verify that the bot token has the im:write scope and that the bot has a prior conversation with the target user. Slack requires either a conversation to exist or the chat:write scope with a direct channel open initiated by an admin. The conversations.open API method can be used to programmatically open a DM channel between the bot and a user before sending a message.