Miro
Visualize and structure ideas
- Category
- Productivity
- Primary Subcategory
- Whiteboards & Visual Collaboration Canvases
View in the ChatGPT registry↗Integration details
Description
Connect ChatGPT to Miro to summarize existing boards, update them, or build new ones from scratch. Point ChatGPT at a board and it reads what your team has already decided, researched, and drawn, so its answers start from your context. Ask it to build, and its answers land on the board as native Miro objects – slides, tables, docs, diagrams, sticky notes, frames, and workshop widgets – visual, instantly editable, and collaborative by default. Key Use Cases: Product strategy review: ChatGPT generates a strategy presentation as Miro slides, alongside your team's priorities, so the team sees the full picture and comes together to review and collaborate on it. From there, ChatGPT reads the feedback and discussion – the call transcript plus Miro comments and stickies – and writes the update for the wider team. System design review: Get ChatGPT to create an interactive architecture diagram and documentation for a team of engineers to review and discuss ahead of upcoming changes. Documentation automation: Set up a scheduled task in ChatGPT to keep your Miro diagrams and documents up to date as things change. Journey mapping: ChatGPT maps out an existing user journey in Miro for the team to review in a collaborative session. From there, any proposed changes can be picked up by ChatGPT and drafted into follow-up items. Invoke Miro directly with @Miro, or just describe what you want in plain language. Try prompts like: - @Miro, summarize the decisions on this board [board URL] - @Miro, turn this strategy doc into slides alongside our priorities - @Miro, diagram this service's architecture with the docs beside it - @Miro, update the journey map on this board with the changes we agreed - @Miro, turn the comments on this board into action items - @Miro, build a retro board for my team with dot voting What Miro can do in ChatGPT: - Read, search, and summarize context from your Miro boards - Create boards, and generate full boards for workshops, retros, and planning sessions - Create slides, diagrams, docs, tables, timelines, sticky notes, and images on the canvas - Update and edit content already on the canvas, and delete what it created - Create and update tables, including kanban and timeline views - Read, reply to, and resolve board comments - Upload images to a board - Create, update, and share Miro spaces
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- Whiteboards & Visual Collaboration Canvases
- Secondary Subcategories
- None listed
- Brand
- Miro
- Access
- Account required
- First tracked
- 2026-07-17
- Tool count
- 57
- Geography
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Get alerts for Miro
Get updates when Miro’s Discoverability Score or category rank changes.
ChatGPT Plugin Discovery Score
ChatGPT Plugin discovery is coming soon
ChatGPT can surface a Plugin when it matches a user's request.Your Plugin Discovery Score measures how often yours appears.
No spam. Unsubscribe any time.
What discovery looks like
Competing in ChatGPT Whiteboards & Visual Collaboration Canvases
View Category57 tools agents can invoke
Get the board-authoring workflow instructions and the DSL (Domain-Specific Language) format specification for creating board items. REQUIRED and FIRST: call this before canvas_create_from_svg, and before canvas_load_format_skill. The first call (no arguments) routes you to the right workflow step; follow the returned instructions and call again with the step value they name. This is the foundational skill -- every use-case skill from canvas_load_format_skill (e.g. diagramming) layers on top of it and assumes you already have it, so never load a format skill before this one. In a conversation, reuse each step's returned instructions instead of re-fetching them.
canvas_get_canvas_composer_skill
Create a typed board format, such as a table, timeline, kanban, document, diagram, prototyping container, slide container, activities board, or embed. Use this tool when the user asks for the document/table/diagram itself as a standalone piece of content (e.g. 'create a doc in Miro about X', 'make me a table of Y'). Prefer it over adding a doc, table or diagram widget to an existing board: those tools are for adding content onto a board the user is already working on. To place the format inside a space, pass parent_space_url - either the space URL or the space content item id. Creating it in the space directly saves the extra board_move call that creating it at the team root would need. IMPORTANT: Always confirm with the user before creating content. This action cannot be undone.
board_create_format
Create board items from a canvas-composer SVG document. Parses the SVG into Miro widgets -- shapes, stickies, text, connectors, frames, tables, docs, images, slide decks, AND structured Mermaid diagrams (flowchart, ERD, UML class/sequence, authored as a <foreignObject data-type="diagram"> with a Mermaid body). This is the primary tool for creating ANY board content, diagrams and presentations included: 'create a diagram' / 'draw a flowchart' are handled here, NOT by the legacy diagram_* tools, and 'build a slide deck' / 'make a presentation' are handled here too. Returns a result_svg with data-miro-id stamped on every svg element for the next iteration.
canvas_create_from_svg
Create a new comment on the Miro board canvas. The comment appears at the specified canvas coordinates and is attributed to the current user. To attach the comment to an existing board item, pass a URL that targets that item. Use list_comments to read existing comments and their positions.
comment_create
USE THIS TOOL whenever the user asks for slides, a deck, a presentation, a pitch, or a slideshow, even a small/informal one (e.g. 'make me 3 slides about X'). Create a Miro slide deck from one or more HTML slides. The deck materializes as a slide_container with child slide frames the next time any user opens the board — no Miro tab needs to be open at creation time. ONE CALL PER DECK: pass EVERY slide of the deck in a single call's input list. There is NO per-call slide limit and no slide count fails on its own — a deck of 3, 10, or 30+ slides is one call. A second call WITHOUT reference_deck_id creates a separate, independent deck; you cannot append to or extend an existing deck, so splitting one deck across several calls fragments it into multiple containers on the board. If a call fails (e.g. transient HTTP 500), fix the offending slide and retry the SAME single call with the full set — NEVER split it into smaller batches, and never infer a slide-count limit from a failure. Images: leave external http/https URLs in the HTML untouched — the server fetches and uploads them for you. ONLY local file references (e.g. './logo.png', 'assets/x.svg') need pre-upload: call image_get_upload_url with src set to the EXACT in-HTML reference, PUT the bytes, then pass the returned tokens via image_tokens below. The server rewrites matching <img src=...> attributes and attaches data-board-resource — do NOT rewrite the HTML yourself. IMPORTANT: ONLY local file references (e.g. './logo.png', 'assets/x.svg') in any part of the HTML like inline, url(), srcset, etc... REQUIRES pre-upload via image_get_upload_url with src set to the EXACT in-HTML reference, then pass the returned tokens via image_tokens below. Fonts: CDN URL only. Author static HTML + CSS only — <script> elements and inline event handlers (onclick etc.) are stripped, so any scripted behavior is silently lost; use CSS states (:hover, :focus) for visual interactivity. Max combined HTML across all slides in one deck: 380,000 bytes — this is the limit that matters for multi-slide decks; budget each slide's HTML accordingly (e.g. ~38,000 bytes/slide for a 10-slide deck). Max per slide: 1,048,576 bytes, but reaching it on any slide in a multi-slide deck will already exceed the combined limit. Provide exactly one input — PREFER html_tokens (HTML stays out of context). html_contents is a last-resort fallback only when the runtime cannot issue an HTTP PUT at all; HTML size, image count, multi-slide, or not yet having the HTML saved to a file are NOT valid reasons — write it to a file yourself, then PUT it. Slide sizing: ALWAYS declare the size explicitly in <head> with <meta name="viewport" content="width=W, height=H"> (e.g. width=1920, height=1080), and give the body the same size in CSS so the content lays out to match. Both axes are required — declaring a width alone is worse than declaring nothing, because the height then falls back to 800 and any shorter slide is padded with empty space instead of being fitted. Undeclared slides fall back to 1280x800. Avoid sizing the body in vh/vw or percentages; use the declared pixel size. Slide label: each slide's HTML must include <meta name="screen:name" content="<label>"> in <head> so the slide gets a meaningful display label; without it a generic placeholder is used. Placement: x/y are board-absolute (board center is (0, 0)), and are for a deck with NO relation to an existing one (e.g. the first deck on a blank board, or the user gave explicit coordinates). Slide order is preserved from the input list. Give it a short descriptive name (e.g. what the user asked for) so the board isn't left with a generic placeholder. Iterating on an existing deck (passing reference_deck_id means you are iterating — deleting slides, modifying slides, adding new slides, or reordering slides in something already on the board): NEVER compute x/y yourself for this case. Understand the outcome before you start, because it is NOT an in-place edit: the deck you reference stays on the board untouched, and this call adds a SECOND deck below it carrying the edited result. There is no way to patch a slide, or a deck, in place. So html_tokens/html_contents must contain the COMPLETE set of slides for the result, not just the ones that changed, and the user is left with two decks to reconcile. Steps: 1. Call slides_read_html (or canvas_search) and check whether the deck being iterated on is present, i.e. already a real board item. 2. If it is NOT present, it either doesn't exist yet (wrong id, or never created — the common case now) or a create you made for it reported requires_apply=true and is still an unapplied AGR suggestion (rare, legacy path only) — check which before continuing. If pending, tell the user to open it and click 'Apply to canvas' first. If it doesn't exist, stop; do not create a new deck against a nonexistent reference. 3. If it IS present, call slides_read_html with include_html=true to get every existing slide's HTML, then build the full ordered list you want in the result: keep untouched slides by re-uploading their HTML unchanged, modify a slide by re-uploading its edited HTML in the same slot, delete a slide by leaving its HTML out entirely, add a slide by inserting its HTML at the desired position, and reorder slides by arranging the list in the desired final order. 4. Pass that full ordered list as html_tokens/html_contents together with reference_deck_id so the new deck is positioned below the original — best-effort, not pixel-exact — and titled the next version (V2, V3, ...) automatically; you do not need to track or pass a version yourself. The name half of the title carries forward from the original too, so only pass name when you want to change it. Also pass if_not_modified_since (the deck_modified_at from the slides_read_html call in step 3) so an edit made to the original since your read is rejected instead of being silently dropped from your copy — on rejection, re-read, reapply your edit, and retry. 5. Report the result honestly: the original deck is still there and was not modified. Once the new deck is confirmed, tell the user the original is now superseded by the new version and is a leftover duplicate they need to delete themselves — no tool here deletes a deck. Never describe this as having updated, replaced, or edited the original deck. On return, check requires_apply. - false: the deck is already a real board item and item_id is the slide_container's own id — use it directly with other tools. - true: the deck is a pending suggestion, not a real board item — the user must open the returned URL and click 'Apply to canvas' before it exists. The applied deck's real id is NOT item_id and cannot be known in advance. To find it afterwards: call canvas_search (result_mode='overview') and pick the slide_container closest to the x/y this call returned — it will be clearly closer than any other deck already on the board. If nothing is clearly closer, don't guess — list the candidates and ask the user which one. Whole-deck resend on edits is normal overhead here, even for quick/draft decks — not a sign that something is wrong or that a lighter-weight approach should be used instead.
slides_create_html
Create an image item on a Miro board. Accepts either an upload token (from image_get_upload_url after the upload completes) or a publicly accessible image URL. Exactly one of image_token or image_url must be provided. When image_token is provided, title/x/y/width from the token (set at upload time) are used; any values supplied here for those fields are ignored. Coordinates: when the URL has no item target, x/y are board-absolute (board center is (0, 0)). When the URL targets a frame via moveToWidget, the image is created INSIDE that frame and x/y are relative to the frame's top-left corner; (0, 0) is the frame's top-left and the image must fit within the frame's width and height.
image_create
Create a new Miro board. To place the board inside a space, pass parent_space_url - either the space URL or the space content item id. Creating it in the space directly saves the extra board_move call that creating it at the team root would need. IMPORTANT: Always confirm with the user before creating a board. This action creates a new board and cannot be undone. IMPORTANT: The created item is NOT shown to the user automatically. Do not restate its link, name, or details in your reply. After all content has been created, call the board_show tool once to display the result to the user.
board_create
Create a new Miro space. A space organizes related content together (Boards; Documents; Tables; Diagrams; etc). Always give the space an icon: use the emoji the user asked for, and when they did not name one, pick a fitting emoji yourself from the space name. IMPORTANT: Always confirm with the user before creating a space. This action creates a new space and cannot be undone.
space_create
Create a Miro prototype from one or more HTML screens. Images: leave external http/https URLs in the HTML untouched — the server fetches and uploads them for you. ONLY local file references (e.g. './logo.png', 'assets/x.svg') need pre-upload: call image_get_upload_url with src set to the EXACT in-HTML reference, PUT the bytes, then pass the returned tokens via image_tokens below. The server rewrites matching <img src=...> attributes and attaches data-board-resource — do NOT rewrite the HTML yourself. IMPORTANT: ONLY local file references (e.g. './logo.png', 'assets/x.svg') in any part of the HTML like inline, url(), srcset, etc... REQUIRES pre-upload: call image_get_upload_url with src set to the EXACT in-HTML reference, PUT the bytes, then pass the returned tokens via image_tokens below. Fonts: CDN URL only. Author static HTML + CSS only — <script> elements and inline event handlers (onclick etc.) are stripped, so any scripted behavior is silently lost; use CSS states (:hover, :focus) for visual interactivity. Max per screen: 1,048,576 bytes. Max screens per call: 20 — split larger prototypes across multiple prototype_create calls. Provide exactly one input — PREFER html_tokens (HTML stays out of context). html_contents is a last-resort fallback only when the runtime cannot issue an HTTP PUT at all; HTML size, image count, multi-screen, or not yet having the HTML saved to a file are NOT valid reasons — write it to a file yourself, then PUT it. Placement: no item target → x/y are board-absolute (center is (0, 0)); moveToWidget on a frame → prototype is created inside, x/y are relative to frame top-left and must fit within frame width/height. All screens in one call share device_type, orientation, and placement; order is preserved.
prototype_create
Create a new section inside a space to group related boards and content. A section must live inside a space, so provide the space URL. If no title is given, a short one is generated from the user's goal. IMPORTANT: Always confirm with the user before creating a section.
section_create
Create a new blog post in a Miro space overview. Use this tool when the user wants to add a blog post or update to a space. Requires the space's content item ID. The title is required (max 150 characters) and content is optional (max 4000 characters). Returns the created blog post's ID.
blog_post_create
Create a table on a Miro board with specified columns. Supports text, select, multiselect, date, link, person, and number column types. This always creates a plain grid table. To produce a timeline, kanban, or tree, first create the table here, then call table_update_view to switch its layout. For a request like 'create a timeline/kanban/tree', do BOTH steps in sequence. Coordinates: when the URL has no item target, x/y are board-absolute (board center is (0, 0)). When the URL targets a frame via moveToWidget, the table is created INSIDE that frame and x/y are relative to the frame's top-left corner; (0, 0) is the frame's top-left and the table must fit within the frame's width and height. If no board URL is provided, a new board will be created. IMPORTANT: Always confirm with the user before creating a new board. IMPORTANT: The created item is NOT shown to the user automatically. Do not restate its link, name, or details in your reply. After all content has been created, call the board_show tool once to display the result to the user.
table_create
Delete a section. Boards inside the section are not deleted; they are moved up to the parent space. IMPORTANT: Always confirm with the user before deleting a section.
section_delete
Get image download URL for an image item from a Miro board.
image_get_url
Find which space a board belongs to.
board_get_space
Reserve one or more single-use upload slots for HTML screens. Set count to the number of screens in the prototype to reserve all slots in a single call instead of calling this once per screen. Returns one entry per slot, each with its own upload_url and token; uploads can run in parallel. PUT the raw HTML as the request body with Content-Type: text/html; no auth header. curl: curl -X PUT -H 'Content-Type: text/html' --data-binary @page.html '<upload_url>'. If the HTML only exists as a string in your context, write it to a local file first (e.g. page.html), then PUT that file — not already having a file is not a reason to fall back to html_contents. Max size: 1,048,576 bytes per screen. External http/https image URLs are fine; the server fetches them. Only local file references need pre-upload (see prototype_create's image_tokens). After each upload, pass its token to prototype_create, in the same order.
prototype_get_upload_url
Use this together with slides_create_html to publish a new slide deck, presentation, pitch, or slideshow from HTML. Call this first to reserve upload slots, then PUT each slide's HTML to the returned URLs. Reserve one or more single-use upload slots for HTML slides. Set count to the number of slides in the deck to reserve all slots in a single call instead of calling this once per slide. Returns one entry per slot, each with its own upload_url and token. PUT every slide's HTML concurrently — start all uploads before waiting on any of them; uploading one at a time defeats the point of batching and is noticeably slower for the end user. PUT the raw HTML as the request body with Content-Type: text/html; no auth header. curl: curl -X PUT -H 'Content-Type: text/html' --data-binary @slide.html '<upload_url>'. If the HTML only exists as a string in your context, write it to a local file first (e.g. slide.html), then PUT that file — not already having a file is not a reason to fall back to html_contents. Max size: 1,048,576 bytes per slide. External http/https image URLs are fine; the server fetches them. Only local file references need pre-upload (see slides_create_html's image_tokens). Slide sizing: declare the size explicitly in <head> with <meta name="viewport" content="width=W, height=H">, and give the body the same size in CSS. Both axes are required; a width alone leaves the height at 800 and pads anything shorter. Undeclared slides fall back to 1280x800. Slide label: include <meta name="screen:name" content="<label>"> in <head> so the slide gets a meaningful display label; without it a generic placeholder is used. Once all uploads complete, pass the full list of tokens to a single slides_create_html call, preserving upload order. A deck is always ONE slides_create_html call: if it has more than 30 slides, reserve slots across several calls here, then combine all tokens into that one create call — never split the deck into multiple create calls.
slides_get_upload_url_html
Fetch the authoring reference for slide layouts - the vocabulary every other tool in this server speaks. Call it once before composing a deck, or whenever a render came back rejected and the contract wording is unclear. It explains what a layout and a slot are; the five slot types (string, raw, enum, list, boolean) and how to write values for each, including exactly which inline tags survive in a raw slot; every field a slot contract can carry (required, default, maxChars, hardMax, recommended, recommendedChars, minItems, maxItems, recommendedItems, recommendedCount, enum, richTextAllowList, item) and whether it is enforced or guidance; how to read the compact slot lines of a summary listing; the difference between the summary and full listing modes and when to ask for each; and the rules that hold for every fill. Static reference content: no collection or layout ids needed, and the answer does not change between calls.
slide_templates_get_template_dsl
Get a single-use upload URL for a local image. Returns upload_url and a token. PUT the raw image bytes as the request body; set Content-Type to the image MIME type; no auth header. curl: curl -X PUT -H 'Content-Type: image/png' --data-binary @image.png '<upload_url>'. If the image only exists as in-memory bytes, write it to a local file first, then PUT that file. After upload, pass the returned token to any tool that accepts an image_token / image_tokens parameter — see each consumer tool's description for what it does with the upload. Max size: 6,000,000 bytes. Accepted types: image/bmp, image/gif, image/jpeg, image/png, image/svg+xml, image/vnd.adobe.photoshop.
image_get_upload_url
Get the pixels of an image item on a Miro board. Use this when a layout shows an image (by its properties and source URL) and you need to see what the image actually depicts. Returns the image content directly.
image_get_data
List who can access a board or space and the role each of them holds. Use this to answer who a board or space is shared with, or what access somebody has. Each entry names the subject, its kind, the role it holds and, for users, their email address. User groups have no email, so identify them by their subject id. Entries whose kind is 'user' or 'user_group' and whose role is one of owner, coowner, editor, commenter or viewer can be fed straight into board_role_update or space_role_update. Access granted by other means is still listed, under its own kind or role name such as 'team' or 'private', and cannot be changed with those tools. Results are paginated: pass the returned cursor back to fetch the next page.
content_item_list_roles
List the available slide-template collections. Call this first whenever the user wants a deck, presentation or slides built from ready-made layouts. A collection is a named set of on-brand layouts to compose a deck from, with a description of what it covers and how many layouts it holds. Take its id, then call list_collection_templates for it. Returns collection metadata only; no slide content.
slide_templates_list_collections
List the slide layouts in one collection. Called with a collection id alone it returns one compact entry per layout - the layout id, title and what job it does - which is what choosing layouts needs. Call it again with template_ids for the handful of layouts you decided to use to get their full slot contracts (typed slots with per-slot guidance and limits), before writing content. Requesting every contract at once wastes context. The full contracts are written in the vocabulary that get_template_dsl defines - slot types, which limits are enforced, how to read a slot line - so fetch that reference first if you have not already. Returns contracts only - never the slide markup, which stays out of the conversation.
slide_templates_list_collection_templates
List all blog posts or updates or feed in a Miro space overview. Use this tool to discover what blog posts exist in a space, e.g. to read updates, summaries, or action items. Takes the space's content item ID. Returns each blog post's ID, title, content, owner, type, and timestamps.
blog_post_list
List the boards inside one specific space. Requires the identifier or URL of that space, so use it only when the user names a particular space (e.g. 'boards in the Design space'). For team-level requests (e.g. 'list boards in my team'), list the team's spaces first with the list spaces tool.
space_list_boards
List the direct children of a space or section, one level deep. Provide the content item id of a space or a section, and it returns each immediate child's content item id, type (e.g. board, folder, doc, diagram) and title, plus a board URL when the child is a board. Use it to explore what sits directly inside a space or section (e.g. its boards and sub-sections). The id must belong to a space or a section; other content items are rejected. Results are paginated: pass the returned cursor to fetch the next page.
space_list_children
List the spaces in the current user's team. Spaces are the top-level containers that organize a team's boards and other content, so this is the primary entry point for exploring what a team has. Prefer this tool for any team-level listing request, including phrasings like 'list boards in my team', 'what's in my Miro team', 'show my team's content', or 'get team spaces'. To then list the boards inside a particular space, use the space boards tool.
space_list
Load supplementary authoring guidance (a skill) for a specific composition format, layered ON TOP OF the general canvas format. PREREQUISITE: call canvas_get_canvas_composer_skill FIRST -- this tool assumes you already know the SVG board format and only adds format-specific styling and examples. Do not call it as your first step, and never in place of the composer skill. Content is still created with canvas_create_from_svg / canvas_update_from_svg. Available formats: 'diagramming' (styling and worked examples for Mermaid diagram widgets), 'presentation' (design guidance for slide decks; available where the composer skill lists the SLIDE_CONTAINER widget) and 'prototyping' (HTML authoring contract and design guidance for prototype screens; available where it lists the PROTOTYPING_CONTAINER widget). For 'diagramming', pass the notation you are drawing to get that notation's color defaults and worked example. Call once per format/notation in a conversation and reuse the guidance.
canvas_load_format_skill
Move an existing Miro board under a space or folder. Use this tool when a user asks to move a board into a space or under a folder. Provide the board and the content item id of the destination space or folder.
board_move
Move a board to a different team.
board_move_to_team
Check whether a Miro create-result preview resource is ready. Returns pending until the preview is available. Tags: preview, resource.
preview_resource_poll
Read one board area or specific items as a canvas-composer SVG document. Use canvas_search to find a scope, then provide all four scope fields. Area reads fail above 500 widgets; narrow the scope and retry. Use widget_ids only for specific items; selecting a container (a frame, slide deck, or prototype) includes everything nested inside it. Name an html_content item in widget_ids to read its HTML source while the document stays within the 200,000-character update limit; area reads and nested items omit it.
canvas_read_as_svg
List comments from a Miro board or a specific item on the board. Comments include author information, messages (original comment and replies), reactions, resolved status, and position. Use limit and offset for pagination. Use from_date and to_date to filter by creation time. Use resolved to filter by resolved status.
comment_list_comments
Use this tool first whenever the user wants to view, inspect, or read existing slides, a slide deck, a presentation, a pitch, or a slideshow. Not for creating a new deck — use slides_create_html for that. Not for generic Miro frames — only HTML-based slides are covered. Read HTML slides from a Miro board. Returns slides with metadata (position, dimensions) and optionally their HTML markup. Covers both deck slides (HTML slides inside a slide deck container) and standalone HTML content widgets on the canvas. Non-HTML slide types are ignored. Provide deck_id to scope results to a specific deck, or omit to list all HTML slides on the board. If the query can be resolved using metadata alone (slide position, deck membership, dimensions), always call with include_html=false first to identify the minimal target set, then fetch include_html=true only for those slides. Only skip the metadata step when the query requires filtering on HTML content itself (e.g. 'find slides containing X text') — in that case fetch HTML directly, but scope to a specific deck_id where possible to avoid loading the entire board. When scoped to a deck_id, the response includes deck_modified_at (latest slide edit in that deck). Before iterating on a deck with slides_create_html's reference_deck_id, capture this value and pass it back as if_not_modified_since — that call rejects the edit if the deck changed after this read, so re-read and reapply before retrying. Note that iterating produces a second deck rather than editing this one in place; see slides_create_html.
slides_read_html
Get the history of a row's Latest Update field. The Latest Update field accumulates the text updates submitted for that row over time; this returns those entries ordered chronologically. Provide the table via its Miro URL and the target row via rowId (get rowIds from table_list_rows). Response includes for each entry: text, author_id (Miro user ID of the author), created_at and modified_at (ISO 8601 timestamps), plus the total number of entries.
table_get_latest_update_history
Read prototype screens from a Miro board. Returns prototype screens with metadata (position, dimensions, device type) and HTML markup representing each screen's UI layout. Useful for AI tools to understand the design, structure, and navigation flow of interactive prototypes. Provide screen_id to read a specific screen, or omit to list all screens on the board. Recommended workflow: first list all screens with include_html=false (default) to get metadata, then read a specific screen with include_html=true to get its HTML markup.
prototype_read
Get rows from a Miro table with column metadata. Each row includes a stable rowId that uniquely identifies it within the table. rowIds persist across sorting, insertion, and deletion — use them to target specific rows in table_sync_rows. Supports filtering by column value. Returns text, select, multiselect, and latest_update columns. Best practice: always use filter_by and limit when possible.Examples: next item that is not done: {"filter_by": {"Status":["To do", "In progress"]}, "limit": 1}top 5 high priority tasks: {"filter_by": {"Priority":["High"]}, "limit": 5} Response includes for each row: rowId (stable row identifier), cells (array of columnTitle, valueType, content, options, latest_update_text, latest_update_author_id). Pagination: Use 'limit' to control page size (default 10) and 'next_cursor' to fetch subsequent pages. The cursor is opaque and encodes pagination state. IMPORTANT: Do not change 'filter_by' when using a cursor from a previous response, as this will result in an error. To apply a different filter, start a new pagination sequence (no cursor).
table_list_rows
Record a thumbs up/down rating a user gave on a Miro MCP UI response, attributed to the current MCP session. Tags: feedback, rating, ui.
record_ui_feedback
Fill the chosen layouts with content to produce the finished slides. Pass the collection_id the layouts came from, plus one entry per slide in presentation order: the layout id plus the values for that layout's slots, exactly as described by list_collection_templates. Sequence the deck as an arc rather than a dump: open, set context, show the thing, give evidence, close on what happens next. One idea per slide, a headline that states the point rather than labelling it, and plain copy inside each slot's recommended band. Content beyond a slot's hard maximum is rejected with the field, the limit, the actual size and what to change - shorten the named field and call again. Rejection publishes nothing at all: fix the named fields and call again with the whole deck. ONE CALL PER DECK: every slide of the deck goes in a single call, in presentation order. A second call creates a separate, independent deck - it cannot append to or edit an existing one. Images: an image slot takes either an external https URL (fetched server-side, no token needed) or a local-style board-resource name such as 'hero.png', which REQUIRES a matching token in this call's image_tokens. Leave an image slot empty and the layout renders an on-brand placeholder for the user to swap on the board - that is a valid finished slide, so never invent, generate or screenshot an image to fill one. The deck is created as a pending suggestion: the user must open the returned URL and click 'Apply to canvas' before it becomes a real board item. Returns a per-slide manifest and the deck URL, never the slide markup.
slide_templates_render
Add a reply message to an existing comment thread on a Miro board. Use list_comments to find comment IDs. The reply appears as the last message in the thread and is attributed to the current user.
comment_reply
Resolve or unresolve a comment thread on a Miro board. Resolving marks the thread as addressed; unresolving reopens it. Use list_comments with resolved=false to find open threads.
comment_resolve
Restore one or more boards from trash.
board_restore
Search and list boards accessible to the current user, scoped to their team. Returns board metadata — name and URL — suitable for navigating to a specific board or discovering relevant boards before operating on them. Use this tool when the user wants to find a board by name or description, or discover which boards are available before using other board tools. Supports offset-based pagination.
board_search_boards
Search and navigate board content on top of the canvas-composer SVG representation to find relevant items and areas. Use canvas search beforehand to narrow down scope of a read.
canvas_search
Grant a user or user group access to a board with a specific role. Use to share a board with someone who does not yet have access. If they already have a role, use board_role_update instead. IMPORTANT: Always confirm with the user before changing who can access a board.
board_share
Grant a user or user group access to a space with a specific role. Use to share a space with someone who does not yet have access. If they already have a role, use space_role_update instead. IMPORTANT: Always confirm with the user before changing who can access a space.
space_share
Show a single interactive preview of items on a Miro board. Call this ONCE at the end of a board-building workflow, after all content has been created, instead of describing the board in text. Do not call it on an empty board or after every create step. Provide a URL with a moveToWidget or focusWidget parameter to preview that item, leave empty for multiple items. IMPORTANT: The board preview is displayed to the user in an interactive panel with its link. Do not restate the link or describe the board contents in your reply; respond with at most a brief confirmation.
board_show
Update a board's title, description and/or icon emoji. Omitted fields are left unchanged. To remove the board's icon, pass an empty string as icon_emoji.
board_update_metadata
Change the role of a user or user group that already has access to a board. If they do not yet have access, use board_share instead. IMPORTANT: Always confirm with the user before changing who can access a board.
board_role_update
Apply a canvas-composer SVG document to the board by diffing it against the live board (matched on data-miro-id) and applying only the deltas: it creates new elements, updates existing ones, and deletes elements explicitly marked with data-deleted="true" (which must carry the element's data-miro-id). Removing an element from the SVG does NOT delete it, deletion is explicit per element, so a partial document is always safe. Deletion is destructive and not undoable here: confirm the specific items with the user before sending any data-deleted="true". Feed the result_svg from a previous canvas_create_from_svg or canvas_update_from_svg call back in to iterate. Returns a result_svg with data-miro-id stamped on every element for the next iteration.
canvas_update_from_svg
How do I improve a ChatGPT Plugin's discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
What are Miro alternatives on ChatGPT?
As of 2026-09-28, Miro competes with B&A: Draw Sketches, B&A: Sketch, Canvs.io whiteboard, Klaxoon, Padlet, Whimsical, Whiteboard by Athena AI in ChatGPT Whiteboards & Visual Collaboration Canvases, ranked by public Discoverability Score.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.