Miro MCP Server: Boards Into Your Coding Agent

The Miro MCP server is Miro’s own, hosted Model Context Protocol server at https://mcp.miro.com/. It lets an AI agent such as Claude, Claude Code, Cursor or GitHub Copilot in VS Code search your boards, read what is on them, and create or update content: sticky notes, frames, documents, tables, diagrams and code widgets. You sign in with OAuth and pick one Miro team, and the agent can then reach only the boards you can already open in that team. There is nothing to install or run locally. For developers the useful direction is usually board to code: an agent reads a product brief, a flow or an architecture diagram on a board and works from it. The reverse also works, drawing a sequence or entity-relationship diagram from your code.

Status: official, on every plan, with a recent tool change

The server is Miro’s, not a community project. Miro’s MCP server overview↗ (opens in a new tab) says it works for all Miro plans, including free teams. On Enterprise plans it is off until an admin turns it on, for the whole organization or for selected teams, under Admin settings, then Apps & Integrations, then MCP.

The tool list changed in September 2026. Miro replaced fifteen older board tools (board_list_items and the context_*, layout_*, diagram_* and doc_* families) with a small set of canvas tools, and the removal notice↗ (opens in a new tab) says the old names were removed on September 14, 2026 and now fail if called. Guides and saved prompts from before then name tools that no longer exist, and a few of Miro’s own older pages still mention them. If a client keeps offering the old tools, disconnect the server fully and reconnect it; Miro notes that some clients cache the tool list.

Setup in Claude, Claude Code, Cursor and VS Code

Miro recommends its plugins and connectors over a hand-written entry, and the plugins bring skills along with the server. Every route ends in the same browser sign-in.

• Claude on the web and desktop: in the chat box, choose + then Add connectors, search for Miro, select Connect, and complete the Miro sign-in.
• Claude Code: run claude plugin install miro@claude-plugins-official. Miro’s repository offers the same plugin from its own marketplace, and the manual route is one command, shown below.
• Cursor: install Miro from the Cursor marketplace, or add the server by hand to ~/.cursor/mcp.json for every project or .cursor/mcp.json for one.
• VS Code with GitHub Copilot: install Miro from the MCP registry link in Miro’s docs, or add an HTTP server to your mcp.json. The file itself is covered in the VS Code mcp.json guide.

# Claude Code: add the server, then sign in from inside a session with /mcp
claude mcp add --transport http miro https://mcp.miro.com

# Cursor: ~/.cursor/mcp.json
{
  "mcpServers": {
    "miro": { "url": "https://mcp.miro.com/" }
  }
}

# VS Code: .vscode/mcp.json, or MCP: Open User Configuration
{
  "servers": {
    "miro": { "type": "http", "url": "https://mcp.miro.com/" }
  }
}

Use one route per client. If you install the plugin after adding the server by hand, remove the manual entry so the agent does not see two Miro servers. Gemini CLI, Windsurf, Kiro, Lovable and Replit also have documented setups on Miro’s connection pages.

OAuth and the one-team rule

The first time a tool is called, the client opens a browser window. You sign in to Miro, choose the team that holds your boards, and approve. Miro uses OAuth 2.1 with dynamic client registration, so no API key or app registration is needed on your side; the client stores and refreshes the token. How that sign-in flow works in general is in MCP OAuth, explained.

The part that trips people up is team selection. According to Miro’s MCP FAQ↗ (opens in a new tab), each user is connected to one team at a time, even across several clients. Authorize a different team, in any client, and the earlier connection is replaced; an agent that then asks for a board in the old team gets an error saying the board belongs to a different team. To switch, reauthenticate while viewing a board in the team you want. And always paste the full board URL into the prompt: it is how the agent finds the board.

What it can read and write

The Miro MCP tools reference↗ (opens in a new tab) is the current list. The canvas tools treat a board as an SVG document: the agent reads the board as SVG, edits it, and writes back only what changed.

• Find and read: board_search_boards lists boards you can access; canvas_search finds content on a board, with an overview mode for a first pass; canvas_read_as_svg returns items with a stable ID each.
• Create and change: canvas_create_from_svg adds items, and canvas_update_from_svg applies a diff that can create, update and delete. canvas_get_canvas_composer_skill returns the format the agent must follow and is called once per session before writing.
• Diagrams, docs and tables: flowcharts, ERDs, and UML class and sequence diagrams are written in Mermaid inside the SVG and become native Miro diagrams. Documents are read and edited in place, but an update replaces the whole document body, so the agent must read it first and send back the full text.
• Comments: comment_list_comments, comment_reply and comment_resolve read, answer and resolve threads.
• Other tools: board_create for a new board, image tools that add images from a URL, and prototype_read and prototype_create for Miro prototype screens. The separate table_* tools still work but are marked as deprecating soon.

It is not a full mirror of Miro’s REST API. Miro says the REST API still covers some things the MCP server does not, such as team and organization data, and neither offers webhooks.

From whiteboard to code and tasks

The best results come from boards that already hold decisions: a product brief in a document, a user flow in frames, a data model as an ERD. Prompts that work well:

• Build from a board. “Read the frame called Checkout v2 on <board URL>. Summarize the flow and the open questions, then propose the components and API routes before writing any code.”
• Explain code on a board. “Draw a sequence diagram of how a password reset moves through src/auth and add it to an empty area of <board URL>.”
• Review a pull request visually. “Add an architecture diagram of what this branch changes to a new frame on <board URL>.”
• Act on comments. “List the unresolved comments on <board URL>, group them by screen, and reply to each one you can answer from the code.”

Ask for the summary and the plan before any code, and check the summary against the board yourself: a sticky note that says “maybe” reads the same to a model as one that says “decided”. When the design lives in Figma rather than Miro, the equivalent server is Figma’s MCP server, which is shaped around frames, components and variables rather than whiteboards.

Permissions and limits

• Board access: the agent can see and change only what your account can in the selected team. Access is checked against your current permissions, so losing access to a board also removes the agent’s access.
• Write tools act as you. canvas_update_from_svg can delete items and comment_resolve closes threads others may be watching. Keep your client’s approval prompt on for write tools, especially on shared workshop boards.
• Enterprise controls: admins choose whether MCP is on and for which teams. Miro supports an OIDC identity token with a verified email, which lets a host such as Claude block personal accounts from connecting a company’s Miro.
• Daily limits: every tool call counts toward a daily allowance that rises with the plan. The MCP usage limits page↗ (opens in a new tab) lists 100 calls a day on Free up to 10,000 on Enterprise, reset at midnight UTC.
• Board content is input. Anyone who can edit a board can write text the agent will read, which is indirect prompt injection. Be careful running Miro alongside tools that send, publish or deploy.

Where the tasks go

A board full of stickies is a good place to think and a poor place to track work: nobody can tell which notes were done, and the next session starts from scratch. Miro’s own tables can hold action items, but the work a coding agent picks up needs to live where the code work is tracked. With fenbs connected as a second MCP server at https://fenbs.ai/api/mcp, the agent can read the action items from a retro or a planning board and file each one as a task: feature, enhancement or bug, with the board URL in the note, landing in To Do. It should search the board first so it does not file the same thing twice. A person then sets priority from 1 (most urgent) to 10 and moves what matters to Next Up. If you would rather do it by hand, ask the agent for a plain list and paste it into Add many.

Be clear about what does not carry over. fenbs has no due dates and no assignee field, so the dates and owners on a Miro table stay in Miro or go into the note as text. What the agent adds is recorded in History under its name on your behalf, and if a person decides how board items should be filed, record that as a rule on the Decisions and rules page, which every connected assistant reads first.