Mural Mcp Serveur

io.github.florentlevequePublished by GitHub account florentlevequev2.0.0Updated Oct 29, 2026

Read and write Mural workspaces, rooms, templates, murals and widgets from your AI assistant.

The publisher's own server: Mural

VerifiedStreamable HTTPWeb executableProductivity & WorkflowMedia & Design

Overview

AI-generated overview

Hosted MCP server that lets an AI assistant read and write Mural workspaces, rooms, templates, murals and widgets on your behalf.

What you can do
  • List and inspect workspaces, rooms and the murals inside them, and create rooms
  • Browse and search workspace templates, and create murals from a template
  • Create, read, update, archive, duplicate, delete and export murals, then fetch the export download URL
  • Read, create, update and delete widgets such as sticky notes, shapes, arrows, text boxes, titles and areas
  • Check the connection, granted scopes and sign out, plus a raw API debug call
When to use it
Useful when you work in Mural and want an assistant to set up rooms and murals, generate boards from templates, or bulk-edit sticky notes and other widgets without clicking through the canvas.
Requirements
A remote MCP client that supports Streamable HTTP with OAuth; connect to the hosted server URL and sign in to Mural in the browser. A Mural workspace admin must first enable the server's Unlisted Mural app in the workspace. No local install, client ID or secret is needed.
Before you install
Write tools create, update, archive and permanently delete murals and widgets, and delete-mural is irreversible; the sign-in requests rooms:write, murals:write and templates:write scopes. Mural tokens are stored encrypted server-side in an Upstash Redis database in Frankfurt, and tool calls go to the Mural API with your token. Export download URLs need no authentication to fetch. Mural free-plan limits may cause 403 errors on writes.

Installation

In SourceWeft

  1. Open Mural Mcp Serveur in the dashboard and add it to a workspace.
  2. Connect the required credentials. They are stored privately and never shown on public pages.
  3. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.florentleveque%2Fmural-mcp-serveur/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config. The client completes OAuth sign-in on first connect.

{
  "mcpServers": {
    "mural-serveur": {
      "type": "http",
      "url": "https://mural-mcp-serveur.vercel.app/mcp"
    }
  }
}

README

Mural MCP Serveur

[License: MIT]

A remote Model Context Protocol (MCP) server for the Mural visual collaboration platform. It lets an AI assistant read and write your workspaces, rooms, templates, murals and widgets, on your behalf.

The server is hosted: there is nothing to install and no secret on your machine. Your MCP client connects to one URL and signs you in to Mural in your browser.

text
https://mural-mcp-serveur.vercel.app/mcp

Features

  • Workspaces and rooms: list workspaces and rooms (open rooms included), create rooms
  • Templates: list or search a workspace's templates, create a mural from a template
  • Murals: create (blank or from a template), read, update, archive, delete, duplicate, export and get the export's download URL
  • Widgets: read, create and update sticky notes, shapes, arrows, text boxes, titles and areas; delete widgets
  • Pagination: list tools follow the API cursor and return every item
  • Compact responses: read tools return a trimmed projection of each object to save context; pass verbose: true for the full raw payload
  • OAuth sign-in: the server is its own authorization server, with client registration (CIMD and DCR) and PKCE; Mural is the identity provider behind it

Connect an MCP client

Any MCP client that supports remote servers over Streamable HTTP with OAuth can connect. Give it the server URL; it registers itself and opens the sign-in page in your browser.

Before the first connection, the Mural app of this server must be enabled in your Mural workspace: see Mural access.

Claude Code

bash
claude mcp add --transport http --scope user mural https://mural-mcp-serveur.vercel.app/mcp

Then run /mcp in Claude Code, pick mural and sign in.

Claude (web and desktop) and other clients

Add a custom connector (or remote MCP server) and paste https://mural-mcp-serveur.vercel.app/mcp as its URL. No client ID or secret is needed: the client registers itself.

What the sign-in does

  1. Your browser opens this server's sign-in page, which sends you to Mural.
  2. You sign in to Mural and approve the scopes the tools need.
  3. Unless your client is claude.ai or ChatGPT, this server asks you to confirm which application gets access. It remembers your answer for 90 days.
  4. Your client receives its tokens and the tools appear.

The client's access token lasts 10 minutes and is renewed silently. A connection lasts up to 90 days from sign-in, as long as Mural keeps accepting it; then your client asks you to sign in again. The clear-auth tool signs the connection out.

Upgrading from 1.x

Version 1.x ran on your machine (npx -y @florentleveque/mural-mcp-serveur) with your own Mural OAuth app. That npm package is deprecated: from 2.0, the server is hosted only.

  1. Remove the old entry from your client. In Claude Code: claude mcp remove mural, with the name you gave it (add -s local, -s user or -s project if it exists in several scopes).
  2. Connect to the hosted server as described above.
  3. Delete ~/.mural-mcp-tokens.json, where 1.x kept your Mural tokens. The MURAL_CLIENT_ID and MURAL_CLIENT_SECRET of your own Mural app are no longer used.

Mural access: an Unlisted app

The server signs in to Mural through one Mural OAuth app, published as Unlisted: it is not in Mural's public app directory, and only people who have its listing link can see it.

Listing link: https://app.mural.co/me/integrations/listing/6ff63b23-e411-4e9a-a4c1-97f68f758474

To roll the server out in a Mural workspace:

  1. A workspace admin opens the listing link while signed in to Mural and selects Enable in admin dashboard. Mural enables the app in that admin's workspace and opens the workspace settings at Apps, where the app is listed under Enabled Apps (tested with an admin of a single workspace).
  2. Each member connects their own MCP client (see Connect an MCP client) and signs in with their own Mural account.

Not a workspace admin? Send the listing link to an admin of your workspace and ask them to enable the app.

Mural documents that admins with the link can enable the app in the workspaces they choose, not what a member can do in a workspace where it is not enabled: whether the sign-in or the API calls then fail is not verified. The app's owner reaches every workspace they belong to either way.

Tools Available

Authentication and utilities

  • test-connection: Test the connection to the Mural API and verify authentication
  • clear-auth: Sign this connection out (revokes its tokens and the Mural tokens behind them; the client must sign in again)
  • check-user-scopes: Show the Mural scopes granted to this connection, and those the tools miss
  • debug-api-response: Raw workspaces API response (troubleshooting)

Workspaces

  • list-workspaces: List all workspaces the authenticated user has access to
  • get-workspace: Get detailed information about a specific workspace

Rooms

  • list-workspace-rooms: List a workspace's rooms (option openOnly)
  • list-room-boards: List the murals within a room
  • create-room: Create a room (open/private)

Templates

  • list-workspace-templates: List a workspace's templates (default and custom), or search them by name
  • create-mural-from-template: Create a mural in a room from a template

Murals

  • list-workspace-boards: List a workspace's murals
  • get-board: Get details of a specific mural
  • create-mural: Create a blank mural in a room
  • update-mural: Update a mural (title, status active/archived, dimensions, sharing...)
  • delete-mural: Permanently delete a mural (irreversible)
  • duplicate-mural: Duplicate a mural into a room
  • export-mural: Start an asynchronous export of a mural in a given format (returns an exportId)
  • download-export: Get the signed download URL of an export (no authentication needed to fetch it); returns ready:false while the export is not ready, so call it again until ready

Widgets

  • get-mural-widgets: Get all widgets of a mural (paginated)
  • get-mural-widget: Get a specific widget by id
  • create-sticky-notes: Create sticky notes (up to 1000 per request)
  • update-sticky-note: Update a sticky note
  • create-shapes / create-arrows / create-text-boxes / create-titles / create-areas: Create the corresponding widgets
  • update-widget: Update any widget by kind and id
  • delete-widget: Permanently delete a widget by id

Write tools need the matching Mural scopes (rooms:write, murals:write, templates:write). The sign-in asks for all of them.

Privacy and security

  • The Mural client secret lives on the server only. MCP clients never see a Mural token: they get this server's own tokens, encrypted, bound to its /mcp endpoint and valid 10 minutes.
  • Your Mural tokens are kept server-side, encrypted, in an Upstash Redis database in Frankfurt. The server functions also run in Frankfurt (Vercel region fra1).
  • The server stores no mural content: each tool call goes to the Mural API with your own Mural token, and the answer goes back to your client.

Design and rationale: docs/decisions/oauth-authorization-server.md.

Troubleshooting

  • Mural refuses the sign-in: the app is probably not enabled in your workspace. See Mural access.
  • "Sign in again" or HTTP 401: the connection expired, was signed out with clear-auth, or Mural revoked it. Reconnect from your client (/mcp in Claude Code).
  • HTTP 403 on a write: check the granted scopes with check-user-scopes. Mural's free plan also limits what you can create (for example 3 murals per workspace, open rooms only); its error message says so.

Self-hosting and development

Inspired by

This project is inspired by cogell/mural-mcp.

License

MIT License, see LICENSE.

Source: README.md at commit 1dd7a99

Tools

0
This server asks you to sign in, so SourceWeft could not read its tools without an account and has not indexed them. What a connected account sees can depend on that account and its permissions.

Version history

1
  1. v2.0.0LatestOct 29, 2026

Score

85% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

Other Mural integrations

Mural

co.muralOfficial publisher

Mural's remote MCP server lets an assistant read and write in Mural shared boards to turn complex ideas into visuals.

Streamable HTTPWeb executableAuth
Productivity & WorkflowCredential requiredOct 24, 2026