Alimenter votre agent
La commande propre à l'éditeur. Ce n'est pas un endpoint PlugMCP.
Host a copy with our keys and logs.
npx -y @delorenj/[email protected]Claude Code n'a pas de lien d'installation pour une commande locale. Copiez la commande ci-dessous et exécutez-la dans un terminal.
TRELLO_API_KEY=<secret> TRELLO_TOKEN=<secret> claude mcp add delorenj-mcp-server-trello-github -- npx -y @delorenj/mcp-server-trello@1.8.1À exécuter dans un terminal.
{ "mcpServers": { "delorenj-mcp-server-trello-github": { "command": "npx", "args": [ "-y", "@delorenj/[email protected]" ], "env": { "TRELLO_API_KEY": "<secret>", "TRELLO_TOKEN": "<secret>" } } }}claude_desktop_config.json
URL distante ou commande sur votre machine ? Ce qui distingue les deux installations
Exécuter sur PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
LancerDe l'éditeur
A Model Context Protocol (MCP) server that gives AI agents full access to your Trello boards — cards, lists, checklists, attachments, comments, custom fields, and workspaces — with built-in rate limiting, type safety, and workflow-level tools you won't find in a plain API wrapper, like acceptance-criteria extraction and checklist dependency queries. 57 tools, one install, powered by Bun.
A Model Context Protocol (MCP) server that provides tools for interacting with Trello boards.
npxget_acceptance_criteria pulls a card's AC checklist straight into your agent's context — no competitor offers it.watch_card and watch_list route card and list activity into your Trello notifications.update_list_position), and archive lists.npx and npm work too.For a detailed list of changes, see CHANGELOG.md.
The server is published on npm as @delorenj/mcp-server-trello. Add it to your MCP client and you're done — no clone, no build.
Add the server to your client's MCP configuration:
{
"mcpServers": {
"trello": {
"command": "bunx",
"args": ["@delorenj/mcp-server-trello"],
"env": {
"TRELLO_API_KEY": "your-trello-api-key",
"TRELLO_TOKEN": "your-trello-token"
}
}
}
}
bunx starts fastest, but npx works identically. Get your API key at trello.com/app-key and generate a token from the same page.
Register the server with the CLI:
claude mcp add trello \
--env TRELLO_API_KEY=your-trello-api-key \
--env TRELLO_TOKEN=your-trello-token \
-- bunx @delorenj/mcp-server-trello
The server is listed on the official MCP Registry as io.github.delorenj/mcp-server-trello, so registry-aware clients can discover and install it directly.
This repository also ships a BMAD-compatible skill package for the
Trello MCP server. Install the skill/ directory through your agent's skill
management workflow, or place it in the agent's skills directory.
When an agent activates the skill, it follows skill/SKILL.md. On first use,
the agent runs the bundled installer:
bash skill/scripts/install.sh
The installer builds the MCP server from skill/assets/source/ when Bun is
available. If Bun is unavailable, it falls back to the published Smithery
install path for @delorenj/mcp-server-trello and creates the same local
build/index.js command path used by the skill activation check.
The skill is the agent-facing entry point for this repository.
skill/SKILL.md: Activation, routing, and agent workflow rules.skill/scripts/install.sh: First-run installer for the bundled server.skill/references/trello-mcp/: Focused references for setup, tools,
workflows, and gotchas.skill/assets/source/: Bundled MCP server source used for local builds.For AI agents, start with skill/SKILL.md rather than this README. The README
is the human-facing overview; the skill references are the operational surface
for tool selection and Trello workflow rules.
Maintainers can refresh the bundled source before packaging with:
mise run package
The server can be configured using environment variables. Create a .env file in the root directory with the following variables:
# Required: Your Trello API credentials
TRELLO_API_KEY=your-api-key
TRELLO_TOKEN=your-token
# Optional (Deprecated): Default board ID (can be changed later using set_active_board)
TRELLO_BOARD_ID=your-board-id
# Optional: Initial workspace ID (can be changed later using set_active_workspace)
TRELLO_WORKSPACE_ID=your-workspace-id
# Optional: HTTPS proxy URL (for corporate proxies or restricted networks)
https_proxy=http://your-proxy:8080
# Optional: Restrict access to specific workspaces (comma-separated IDs)
# If set, only the listed workspaces will be accessible via MCP tools
TRELLO_ALLOWED_WORKSPACES=workspace-id-1,workspace-id-2
Proxy Support: If you're behind a corporate proxy or in an environment that routes traffic through a proxy, set the
https_proxyorHTTPS_PROXYenvironment variable. The server will automatically route all Trello API requests through the specified proxy.
You can get these values from:
https://trello.com/b/abc123/example-board)list_workspaces toolStarting with version 0.3.0, the MCP server supports multiple ways to work with boards:
Multi-board support: All methods now accept an optional boardId parameter
- Omit TRELLO_BOARD_ID and provide boardId in each API call
- Set TRELLO_BOARD_ID as default and optionally override with boardId parameter
Dynamic board selection: Use workspace management tools
- The TRELLO_BOARD_ID in your .env file is used as the initial/default board ID
- You can change the active board at any time using the set_active_board tool
- The selected board persists between server restarts (stored in ~/.trello-mcp/config.json)
- Similarly, you can set and persist an active workspace using set_active_workspace
This allows you to work with multiple boards and workspaces without restarting the server.
You can optionally restrict MCP access to specific workspaces using the TRELLO_ALLOWED_WORKSPACES environment variable. This is useful for:
When TRELLO_ALLOWED_WORKSPACES is set:
list_workspaces only returns workspaces in the allowed listlist_boards only returns boards from allowed workspacesset_active_workspace rejects workspaces not in the allowed listlist_boards_in_workspace rejects non-allowed workspace IDscreate_board rejects creation in non-allowed workspacesExample configuration:
# Only allow access to two specific workspaces
TRELLO_ALLOWED_WORKSPACES=697c549ce04dc460af133a75,5f8a3b2c1d4e5f6a7b8c9d0e
If TRELLO_ALLOWED_WORKSPACES is not set or empty, all workspaces the token has access to will be available (default behaviour).
{
name: 'list_boards',
arguments: {}
}
{
name: 'set_active_board',
arguments: {
boardId: "abc123" // ID from list_boards response
}
}
{
name: 'list_workspaces',
arguments: {}
}
{
name: 'set_active_workspace',
arguments: {
workspaceId: "xyz789" // ID from list_workspaces response
}
}
{
name: 'get_active_board_info',
arguments: {}
}
When working with dates in the Trello MCP server, please note the different format requirements:
dueDate): Accepts full ISO 8601 format with time (e.g., 2023-12-31T12:00:00Z)start): Accepts date only in YYYY-MM-DD format (e.g., 2025-08-05)This distinction follows Trello's API conventions where start dates are day-based markers while due dates can include specific times.
Get all items from a checklist by name.
{
name: 'get_checklist_items',
arguments: {
name: string, // Name of the checklist to retrieve items from
boardId?: string // Optional: ID of the board (uses default if not provided)
}
}
Add a new item to an existing checklist.
{
name: 'add_checklist_item',
arguments: {
text: string, // Text content of the checklist item
checkListName: string, // Name of the checklist to add the item to
boardId?: string // Optional: ID of the board (uses default if not provided)
}
}
Search for checklist items containing specific text.
{
name: 'find_checklist_items_by_description',
arguments: {
description: string, // Text to search for in checklist item descriptions
boardId?: string // Optional: ID of the board (uses default if not provided)
}
}
Get a card's (or board's) acceptance criteria, tolerating the common checklist headings teams actually use. A checklist matches if its name equals Acceptance Criteria, AC, DoD, or Definition of Done — compared case-insensitively and whitespace-trimmed. The first alias in that order with any match wins.
{
name: 'get_acceptance_criteria',
arguments: {
cardId?: string, // Optional: ID of the card to scope the search to (recommended to avoid ambiguity)
boardId?: string // Optional: ID of the board (uses default if not provided)
}
}
On a match, returns:
{
found: true,
items: CheckListItem[], // All items of the matching checklist(s), in Trello's order
unmet: CheckListItem[], // The incomplete subset of items
percentComplete: number, // Rounded percentage complete; 0 when there are no items
matchedChecklistName: string // The checklist name as written on the board, original casing
}
When nothing matches, the tool says so explicitly instead of returning an empty list — so "this card has no acceptance criteria" is never confused with "the checklist is named something else":
{
found: false,
reason: string, // Human-readable explanation naming the aliases that were tried
availableChecklists: string[] // Names of the checklists that do exist in the searched scope
}
A checklist that matches but has no items returns found: true with items: [], which is distinct from the not-found response above.
Get a complete checklist with all items and completion percentage.
{
name: 'get_checklist_by_name',
arguments: {
name: string, // Name of the checklist to retrieve
boardId?: string // Optional: ID of the board (uses default if not provided)
}
}
Returns: CheckList object with:
id: Checklist identifiername: Checklist nameitems: Array of CheckListItem objectspercentComplete: Completion percentage (0-100)Update an existing checklist item.
{
name: 'update_checklist_item',
arguments: {
cardId: string, // ID of the card containing the checklist item
checkItemId: string, // ID of the checklist item to update
name?: string, // Optional: new checklist item text
state?: 'complete' | 'incomplete', // Optional: new checklist item state
pos?: number | 'top' | 'bottom', // Optional: new checklist item position
due?: string | null, // Optional: ISO 8601 due date, or null to clear it
dueReminder?: number | null, // Optional: reminder offset in minutes, or null to clear it
idMember?: string | null // Optional: member ID to assign, or null to clear it
}
}
Delete an existing checklist item.
{
name: 'delete_checklist_item',
arguments: {
cardId: string, // ID of the card containing the checklist item
checkItemId: string // ID of the checklist item to delete
}
}
Get comprehensive details of a specific Trello card with human-level parity.
{
name: 'get_card',
arguments: {
cardId: string, // ID of the Trello card (short ID like 'FdhbArbK' or full ID)
includeMarkdown?: boolean // Return formatted markdown instead of JSON (default: false)
}
}
Returns: Complete card data including:
Fetch all cards from a specific list.
{
name: 'get_cards_by_list_id',
arguments: {
boardId?: string, // Optional: ID of the board (uses default if not provided)
listId: string // ID of the Trello list
}
}
Retrieve all lists from a board.
{
name: 'get_lists',
arguments: {
boardId?: string // Optional: ID of the board (uses default if not provided)
}
}
Fetch recent activity on a board.
{
name: 'get_recent_activity',
arguments: {
boardId?: string, // Optional: ID of the board (uses default if not provided)
limit?: number // Optional: Number of activities to fetch (default: 10)
}
}
Add a new card to a specified list.
{
name: 'add_card_to_list',
arguments: {
boardId?: string, // Optional: ID of the board (uses default if not provided)
listId: string, // ID of the list to add the card to
name: string, // Name of the card
description?: string, // Optional: Description of the card
mbs; dueDate?: string, // Optional: Due date (ISO 8601 format with time)
start?: string, // Optional: Start date (YYYY-MM-DD format, date only)
labels?: string[] // Optional: Array of label IDs
}
}
Update an existing card's details.
{
name: 'update_card_details',
arguments: {
boardId?: string, // Optional: ID of the board (uses default if not provided)
cardId: string, // ID of the card to update
name?: string, // Optional: New name for the card
description?: string, // Optional: New description
dueDate?: string, // Optional: New due date (ISO 8601 format with time)
start?: string, // Optional: New start date (YYYY-MM-DD format, date only)
dueComplete?: boolean,// Optional: Mark the due date as complete (true) or incomplete (false)
labels?: string[] // Optional: New array of label IDs
}
}
Send a card to the archive.
{
name: 'archive_card',
arguments: {
boardId?: string, // Optional: ID of the board (uses default if not provided)
cardId: string // ID of the card to archive
}
}
Add a new list to a board.
{
name: 'add_list_to_board',
arguments: {
boardId?: string, // Optional: ID of the board (uses default if not provided)
name: string // Name of the new list
}
}
Send a list to the archive.
{
name: 'archive_list',
arguments: {
boardId?: string, // Optional: ID of the board (uses default if not provided)
listId: string // ID of the list to archive
}
}
Update a list's name, archive state, subscription state, or board. Use update_list_position to reorder lists within a board.
{
name: 'update_list',
arguments: {
listId: string, // ID of the list to update
name?: string, // Optional: New name for the list
closed?: boolean, // Optional: Whether to close (archive) the list
subscribed?: boolean, // Optional: Whether to subscribe to the list
idBoard?: string // Optional: ID of a board to move the list to
}
}
Update the position of a list on the board. Trello uses fractional indexing: each list has a float position, and to place a list between two others, use the average of their positions (e.g., between pos 1024 and 2048, use 1536). Use "top"/"bottom" shortcuts to move to the edges.
{
name: 'update_list_position',
arguments: {
listId: string, // ID of the list to reposition
position: string // "top", "bottom", or a positive numeric string (e.g. "1536")
}
}
Fetch all cards assigned to the current user.
{
name: 'get_my_cards',
arguments: {}
}
Move a card to a different list.
{
name: 'move_card',
arguments: {
boardId?: string, // Optional: ID of the target board (uses default if not provided)
s; cardId: string, // ID of the card to move
listId: string // ID of the target list
}
}
Attach an image to a card directly from a URL.
{
name: 'attach_image_to_card',
arguments: {
boardId?: string, // Optional: ID of the board (uses default if not provided)
cardId: string, // ID of the card to attach the image to
imageUrl: string, // URL of the image to attach
name?: string // Optional: Name for the attachment (defaults to "Image Attachment")
}
}
Attach any type of file to a card from a URL or a local file path (e.g., file:///path/to/your/file.pdf).
{
name: 'attach_file_to_card',
arguments: {
boardId?: string, // Optional: ID of the board (uses default if not provided)
cardId: string,s; // ID of the card to attach the file to
fileUrl: string, // URL or local file path (using the file:// protocol) of the file to attach
name?: string, // Optional: Name for the attachment (defaults to the file name for local files)
mimeType?: string // Optional: MIME type (e.g., "application/pdf", "text/plain", "video/mp4")
}
}
Download an attachment from a card by ID. Attachment IDs are available in the attachments array returned by get_card.
{
name: 'download_attachment',
arguments: {
cardId: string, // ID of the card containing the attachment
attachmentId: string // ID of the attachment to download
}
}
Returns: For image attachments (image/*), returns the image as inline viewable data. For all other file types, returns a JSON object with:
fileName: Original filenamemimeType: MIME type of the filedata: Base64-encoded file contentsAdd a comment to a Trello card.
{
name: 'add_comment',
arguments: {
cardId: string, // ID of the card to comment on
text: string // The text of the comment to add
}
}
Update an existing comment on a card.
{
name: 'update_comment',
arguments: {
commentId: string, // ID of the comment to change
text: string // The new text of the comment
}
}
Delete a comment from a card.
{
name: 'delete_comment',
arguments: {
commentId: string // ID of the comment to delete
}
}
Retrieve all comments from a specific card without fetching all card data.
{
name: 'get_card_comments',
arguments: {
cardId: string, // ID of the card to get comments from
limit?: number // Optional: Maximum number of comments to retrieve (default: 100)
}
}
List all boards the user has access to.
{
name: 'list_boards',
arguments: {}
}
Set the active board for future operations.
{
name: 'set_active_board',
arguments: {
boardId: string // ID of the board to set as active
}
}
List all workspaces the user has access to.
{
s; name: 'list_workspaces',
arguments: {}
}
Set the active workspace for future operations.
{
name: 'set_active_workspace',
arguments: {
workspaceId: string // ID of the workspace to set as active
}
}
List all boards in a specific workspace.
{
name: 'list_boards_in_workspace',
arguments: {
workspaceId: string // ID of the workspace to list boards from
}
}
Get information about the currently active board.
{
s; name: 'get_active_board_info',
arguments: {}
}
Note: Custom fields require Trello Standard plan or higher.
Get all custom field definitions on a board. For dropdown/list fields, also returns the available options with their IDs.
{
name: 'get_board_custom_fields',
arguments: {
boardId?: string // Optional: ID of the board (uses default if not provided)
}
}
Returns: Array of custom field definitions including:
text, number, checkbox, date, list)list type fields: available options with IDs (use these IDs when setting values)Set or clear a custom field value on a card.
{
name: 'update_card_custom_field',
arguments: {
cardId: string, // ID of the card to update
customFieldId: string,// ID of the custom field definition
type: string, // Field type: 'text' | 'number' | 'checkbox' | 'date' | 'list' | 'clear'
value?: string // The value to set (not needed when type is 'clear')
}
}
Value format by type:
text: any stringnumber: numeric string (e.g. "42.5")checkbox: "true" or "false"date: ISO 8601 string (e.g. "2025-12-31T00:00:00.000Z")list: option ID from get_board_custom_fieldsclear: omit value to remove the field valueThe Trello MCP server pairs beautifully with @flowluap/ideogram-mcp-server for AI-powered visual content creation. Generate images with Ideogram and attach them directly to your Trello cards!
// Using ideogram-mcp-server
{
name: 'generate_image',
arguments: {
prompt: "A futuristic dashboard design with neon accents",
aspect_ratio: "16:9"
}
}
// Returns: { image_url: "https://..." }
// Using trello-mcp-server
{
name: 'attach_image_to_card',
arguments: {
cardId: "your-card-id",
imageUrl: "https://...", // URL from Ideogram
name: "Dashboard Mockup v1"
}
}
Add both servers to your Claude Desktop configuration. Use bunx for the fastest startup.
{
"mcpServers": {
"trello": {
"command": "bunx",
"args": ["@delorenj/mcp-server-trello"],
"env": {
"TRELLO_API_KEY": "your-trello-api-key",
"TRELLO_TOKEN": "your-trello-token"
}
},
"ideogram": {
"command": "bunx",
"args": ["@flowluap/ideogram-mcp-server"],
"env": {
"IDEOGRAM_API_KEY": "your-ideogram-api-key"
}
}
}
}
Now you can seamlessly create visual content and organize it in Trello, all within Claude!
The server implements a token bucket algorithm for rate limiting to comply with Trello's API limits:
Rate limiting is handled automatically, and requests will be queued if limits are reached.
The server provides detailed error messages for various scenarios:
git clone https://github.com/delorenj/mcp-server-trello
cd mcp-server-trello
bun install
bun run build
To run the tests, run the following command:
bun test
The evals package loads an mcp client that then runs the index.ts file, so there is no need to rebuild between tests. You can load environment variables by prefixing the bunx command. Full documentation can be found here.
OPENAI_API_KEY=your-key bunx mcp-eval src/evals/evals.ts src/index.ts
Contributions are welcome!
This project is licensed under the MIT License - see the LICENSE file for details.
A Model Context Protocol (MCP) server that provides tools for interacting with Trello boards.
{ "mcpServers": { "delorenj-mcp-server-trello-github": { "command": "npx", "args": [ "-y", "@delorenj/[email protected]" ], "env": { "TRELLO_API_KEY": "<secret>", "TRELLO_TOKEN": "<secret>" } } }}Outils
Pas encore de liste d'outils. Les serveurs distants en obtiennent une après le premier contrôle d'état.
FAQ
Copiez sur cette page la configuration stdio pour Cursor, Claude Desktop, Claude Code ou VS Code. Elle utilise l'installation de l'éditeur, pas un proxy PlugMCP.
L'éditeur indique ces variables d'environnement : TRELLO_API_KEY, TRELLO_TOKEN.
MCP Server Trello s'exécute en local via stdio.
Dernière vérification : 2026-11-05. A Model Context Protocol (MCP) server that provides tools for interacting with Trello boards.