> For the complete documentation index, see [llms.txt](https://docs.p0.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.p0.dev/agentic-access/agentic-gateway/mcp-server/miro.md).

# Miro MCP server

Install the Miro (AI) integration and its MCP server so agents behind the P0 AI Gateway can request a role on one Miro board at a time.

The **Miro (AI)** integration lets agents behind the P0 AI Gateway (see [P0 Runtime Access for AI](https://docs.p0.dev/readme/agentic-control-plane.md)) request a role on one board in one of your Miro teams. When a request is approved, P0 adds the requester's own Miro user to the board at that role. The agent reaches the board through Miro's hosted MCP server, signed in as the requester. When the grant ends, P0 puts back the role the requester had before, or removes them from the board.

Agents can request three roles on a board:

* `viewer`: open the board.
* `commenter`: also comment.
* `editor`: also change the board.

{% hint style="info" %}
The Miro (AI) integration is in beta. Functionality and configuration may change.
{% endhint %}

P0 never holds your Miro token. A connector you deploy on AWS Lambda or Google Cloud Run makes every call to Miro, with the token of a Miro user you create for it, read from your own AWS Secrets Manager or Google Secret Manager.

Setup has these parts, in this order:

1. Prepare Miro: the connector user, its app, and its token.
2. Deploy the Miro (AI) connector.
3. Register each Miro team.
4. Add the Miro (board access) MCP server to your gateway.
5. Write the policies that decide which agents get which boards.

You can do steps 2 and 3 in the P0 app or with Terraform (see [#install-with-terraform](#install-with-terraform "mention")).

## Prerequisites

* A registered [Gateway](https://docs.p0.dev/agentic-access/agentic-gateway/gateway.md) component, with the gateway deployed in your environment.
* An AWS account or a Google Cloud project to run the connector in, and permission to apply Terraform there.
* AWS Secrets Manager or Google Secret Manager in the same cloud as the connector, to hold the token.
* A Miro user who can add members to the team and share its boards.

## Prepare Miro

1. **Create a Miro user for P0's connector**, and add it to the team. On a free plan it takes one of the team's seats.
2. **Get the app approved**, if the team restricts which apps can be installed. A Team Admin approves the app you create in the next step.
3. **Create a private Miro app**, signed in as the connector user, with the scopes `boards:read`, `boards:write` and `team:read`. Leave **Expire user authorization token** unchecked, so the token doesn't expire.
4. **Store the token.** Click **Install app and get OAuth token**, then store the token as a secret in AWS Secrets Manager or Google Secret Manager. The secret holds the token alone. Note the secret's name.
5. **Make the connector user co-owner of each board** people should be able to request. P0 can only share boards where the connector user is owner or co-owner.

A token keeps the scopes it was issued with. If you add a scope to the app later, install the app again and store the new token.

## Deploy the Miro (AI) connector

1. Navigate to **Integrations** on [p0.app](https://p0.app), select **Miro (AI)**, and choose the **connector** component.
2. Click **Add connector** and fill in the connector's details, then click **Next**:
   * **Connector ID**: the name P0 uses for this connector, such as `miro-prod`. Use lowercase letters, digits and hyphens, starting and ending with a letter or digit, up to 63 characters.
   * **Connector hosting**: **AWS Lambda** or **Google Cloud Run**, with the AWS account ID or Google Cloud project ID, a connector name and a region.
3. P0 generates a Terraform configuration that deploys the connector. Copy it into your Terraform project, `apply` it, then click **Next**. On Google Cloud, the connector runs as the service account `<connector-name>@<project-id>.iam.gserviceaccount.com`.
4. When you click **Next**, P0 checks that it can reach the connector. A new Cloud Run service can take a minute to start. If the check fails, wait a minute and click **Next** again.
5. Review the summary and click **Finish**.

One connector serves every Miro team you register.

## Register a Miro team

1. On the **Miro (AI)** integration, choose the **team** component and click **Add team**.
2. Fill in the team's details, then click **Next**:
   * **Team identifier**: the name agents, policies and the CLI use for this team in P0, such as `design`. The same rules apply as for the connector ID.
   * **Connector**: the connector that reaches this team. It must run in the same cloud as the token's secret.
   * **Secret manager provider**: where the token's secret is.
   * **Access token secret**: the secret's name, not its ARN or full resource name.
3. P0 shows the Miro steps from [#prepare-miro](#prepare-miro "mention") and the Terraform that lets the connector read the secret. Apply it, then click **Next**.
4. P0 checks the team. The connector reads the token, checks that it has the three scopes, and counts the boards the connector user owns or co-owns. A missing scope fails the check. Zero boards shows a warning: nothing can be requested until the connector user owns or co-owns a board.
5. Review the summary and click **Finish**. The team now appears with the state **Installed**.

P0 refuses a second team item for the same Miro team.

## Install with Terraform

{% hint style="info" %}
The `p0_miro_ai_*` resources require [P0 Terraform provider v0.88.0](https://github.com/p0-security/terraform-provider-p0/releases/tag/v0.88.0) or later.
{% endhint %}

Instead of the P0 app, you can install the connector and teams with the P0 Terraform provider (see [Manage integrations as code with the P0 Terraform provider](https://docs.p0.dev/getting-started/get-started-with-the-p0-terraform-provider.md)). You still prepare Miro and store the token as described above. Create the resources in this order:

1. **Stage the connector** with [`p0_miro_ai_connector_staged`](https://registry.terraform.io/providers/p0-security/p0/latest/docs/resources/miro_ai_connector_staged). P0 gives you the names the connector's deployment needs.
2. **Deploy the connector** to AWS Lambda or Google Cloud Run.
3. **Install the connector** with [`p0_miro_ai_connector`](https://registry.terraform.io/providers/p0-security/p0/latest/docs/resources/miro_ai_connector). P0 checks that it can reach the connector.
4. **Add each team** with [`p0_miro_ai_team`](https://registry.terraform.io/providers/p0-security/p0/latest/docs/resources/miro_ai_team). Set `id`, `connector`, `vault` and `token_secret_name`. P0 sets `team_id` and `shareable_boards`.

Keep the token out of Terraform. Create the secret's value with your cloud's CLI, so it never enters Terraform's state.

## Add the Miro (board access) MCP server

You can add the Miro (board access) MCP server once at least one Miro team is installed.

1. Follow the shared steps in [MCP server](https://docs.p0.dev/agentic-access/agentic-gateway/mcp-server.md#add-an-mcp-server) to name the server and choose its gateway. On the configuration screen, set the following fields, then click **Finish**:
   * **Credential source**: choose **OAuth**.
   * **Definition**: choose **P0**, then select **Miro (board access)**.
2. The server now appears with the state **Installed**.

Each user signs in to Miro with OAuth the first time they use the server through the gateway. Sign in to Miro's MCP as yourself, or your agent won't see the board.

The SaaS **Miro** server (see [SaaS MCP servers](https://docs.p0.dev/agentic-access/agentic-gateway/mcp-server/saas.md)) reaches the same Miro MCP server without board grants. Use **Miro (board access)** for the access this page describes.

## How agents request access

An agent requests a role on a board by naming the gateway, the MCP server's identifier, the team by its P0 identifier, the board by its ID, and a role. The board ID is in the board's URL, as in `https://miro.com/app/board/<id>/`. Requests come only from agent sessions, and each needs a duration. Written as a CLI command, a request for `viewer` on a board in the `design` team is:

```bash
p0 request miro-ai board my-gateway miro design uXjVOakxTk0= viewer --duration 1h --reason "Read the launch plan"
```

The arguments are the gateway, the MCP server's identifier, the team, the board and the role.

P0 grants the role to your own Miro user, so both you and your agent can open the board while the grant lasts. Access usually works within a few seconds of approval, and can take up to a minute.

* Only boards where the connector user is owner or co-owner can be requested. A free Miro team holds 3 boards.
* P0 refuses a requester who isn't a member of the team, or who hasn't yet accepted their invite to it. P0 never invites anyone to a team.
* If the requester already has the role or a higher one on the board, P0 changes nothing, and changes nothing when the grant ends.
* Miro shows every share and role change as made by the connector user.

When the grant ends, P0 lowers the requester to the highest role another open grant on the board still gives, or to the role they had before. If someone changed their role in Miro during the grant, P0 leaves it as it is and shows that on the grant. If the connector user is no longer the board's owner or co-owner, P0 can't take the access back: the grant shows that its revoke failed. Give the connector user the role again, then retry the revoke in P0.

See [Requesting access](https://docs.p0.dev/agentic-access/using-the-gateway/requesting-access.md) for how agents submit and use requests.

## What the agent can reach

The agent acts in Miro as the requester. It reaches the granted board, and every board the requester can already open in the team they chose when they signed in to Miro. Miro enforces the role on each call, so a `viewer` can't change the board.

P0 never grants the tools that share boards or reach across the team, whatever the role:

* `board_share`, `board_role_update`, `space_share` and `space_role_update`
* `board_search_boards`, `board_move_to_team` and `user_search_organization_users`
* every `space_*` tool

## Write policies for Miro

Match Miro requests in an agentic access policy (see [Agentic access policies](https://docs.p0.dev/agentic-access/agentic-access-policies.md)) with `service: miro-ai` and `accessType: board`. Three filters narrow them:

* `team`: the team, keyed on `id`, the identifier you gave it in P0.
* `board`: the board, keyed on its Miro `id` or its `name`.
* `role`: `viewer`, `commenter` or `editor`, keyed on `name`.

Patterns match anywhere in the value unless you anchor them, so start each pattern with `^` and end it with `$` where you mean the whole value. A board's name can be changed by anyone who can edit the board, so key a rule that must hold on the board's `id`.

For example, auto-approve `viewer` on any board in the `design` team whose name starts with `[Public]`:

```yaml
- requestor:
    type: agentic
    actor:
      type: any
    subject:
      type: any
  resource:
    type: integration
    service: miro-ai
    accessType: board
    filters:
      team:
        effect: keep
        key: id
        pattern: ^design$
      board:
        effect: keep
        key: name
        pattern: ^\[Public\]
      role:
        effect: keep
        key: name
        pattern: ^viewer$
  approval:
    - type: persistent
```

## Next steps

* Define the [Agentic access policies](https://docs.p0.dev/agentic-access/agentic-access-policies.md) that determine which agents and users may request Miro access.
