# Excalidraw MCP

```json
{
  "name": "Excalidraw MCP",
  "slug": "excalidraw_mcp",
  "url": "https://composio.dev/toolkits/excalidraw_mcp",
  "markdown_url": "https://composio.dev/toolkits/excalidraw_mcp.md",
  "logo_url": "https://logos.composio.dev/api/excalidraw_mcp",
  "categories": [
    "design & creative tools"
  ],
  "is_composio_managed": false,
  "updated_at": "2026-08-09T06:42:19.917Z"
}
```

![Excalidraw MCP logo](https://logos.composio.dev/api/excalidraw_mcp)

## Description

Securely connect your AI agents and chatbots (Claude, ChatGPT, Cursor, etc) with Excalidraw MCP or direct API to create hand-drawn diagrams, edit scenes, control the viewport camera, and open fullscreen editing through natural language.

## Summary

Excalidraw MCP is a no-auth MCP server for creating hand-drawn style diagrams in Excalidraw.
Use it to generate visual sketches with viewport camera control and fullscreen editing.

## Categories

- design & creative tools

## Toolkit Details

- Tools: 5

## Images

- Logo: https://logos.composio.dev/api/excalidraw_mcp

## Authentication

- **No Auth**
  - Type: `custom`
  - Description: No Auth authentication for Excalidraw MCP.
  - Setup:
    - Configure No Auth credentials for Excalidraw MCP.
    - Use the credentials when creating an auth config in Composio.

## Suggested Prompts

- Create hand-drawn system architecture diagram
- Draw user onboarding flowchart with notes
- Open fullscreen editor for wireframe review

## Supported Tools

| Tool slug | Name | Description |
|---|---|---|
| `EXCALIDRAW_MCP_CREATE_VIEW` | Create view | Renders a hand-drawn diagram using Excalidraw elements. Elements stream in one by one with draw-on animations. Call read_me first to learn the element format. |
| `EXCALIDRAW_MCP_EXPORT_TO_EXCALIDRAW` | Export to excalidraw | Upload diagram to excalidraw.com and return shareable URL. |
| `EXCALIDRAW_MCP_READ_CHECKPOINT` | Read checkpoint | Read checkpoint state for restore. |
| `EXCALIDRAW_MCP_READ_ME` | Read me | Returns the Excalidraw element format reference with color palettes, examples, and tips. Call this BEFORE using create_view for the first time. |
| `EXCALIDRAW_MCP_SAVE_CHECKPOINT` | Save checkpoint | Update checkpoint with user-edited state. |

## Supported Triggers

None listed.

## Installation and MCP Setup

### Path 1: SDK Installation

#### Path 1, Step 1: Install Composio

Install the Composio SDK
```python
pip install composio_openai
```

```typescript
npm install @composio/openai
```

#### Path 1, Step 2: Initialize Composio and Create Tool Router Session

Import and initialize Composio client, then create a Tool Router session
```python
from openai import OpenAI
from composio import Composio
from composio_openai import OpenAIResponsesProvider

composio = Composio(provider=OpenAIResponsesProvider())
openai = OpenAI()
session = composio.create(user_id='your-user-id')
```

```typescript
import OpenAI from 'openai';
import { Composio } from '@composio/core';
import { OpenAIResponsesProvider } from '@composio/openai';

const composio = new Composio({
  provider: new OpenAIResponsesProvider(),
});
const openai = new OpenAI({});
const session = await composio.create('your-user-id');
```

#### Path 1, Step 3: Execute Excalidraw MCP Tools via Tool Router with Your Agent

Get tools from Tool Router session and execute Excalidraw MCP actions with your Agent
```python
tools = session.tools
response = openai.responses.create(
  model='gpt-4.1',
  tools=tools,
  input=[{
    'role': 'user',
    'content': 'Create an Excalidraw diagram showing a user signup flow with frontend, API, database, and email verification, then fit it to the viewport.'
  }]
)
result = composio.provider.handle_tool_calls(
  response=response,
  user_id='your-user-id'
)
print(result)
```

```typescript
const tools = session.tools;
const response = await openai.responses.create({
  model: 'gpt-4.1',
  tools: tools,
  input: [{
    role: 'user',
    content: 'Create an Excalidraw diagram showing a user signup flow with frontend, API, database, and email verification, then fit it to the viewport.'
  }],
});
const result = await composio.provider.handleToolCalls(
  'your-user-id',
  response.output
);
console.log(result);
```

### Path 2: MCP Server Setup

#### Path 2, Step 1: Install Composio

Install the Composio SDK for Python or TypeScript
```python
pip install composio claude-agent-sdk
```

```typescript
npm install @composio/core ai @ai-sdk/openai @ai-sdk/mcp
```

#### Path 2, Step 2: Initialize Client and Create Tool Router Session

Import and initialize the Composio client, then create a Tool Router session for Excalidraw MCP
```python
from composio import Composio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions

composio = Composio(api_key='your-composio-api-key')
session = composio.create(user_id='your-user-id')
url = session.mcp.url
```

```typescript
import { Composio } from '@composio/core';

const composio = new Composio({ apiKey: 'your-api-key' });
const session = await composio.create('your-user-id');
console.log(`Tool Router session created: ${session.mcp.url}`);
```

#### Path 2, Step 3: Connect to AI Agent

Use the MCP server with your AI agent (Anthropic Claude or Mastra)
```python
import asyncio

options = ClaudeAgentOptions(
    permission_mode='bypassPermissions',
    mcp_servers={
        'tool_router': {
            'type': 'http',
            'url': url,
            'headers': {
                'x-api-key': 'your-composio-api-key'
            }
        }
    },
    system_prompt='You are a helpful assistant with access to Excalidraw MCP tools.',
    max_turns=10
)

async def main():
    async with ClaudeSDKClient(options=options) as client:
        await client.query('Create an Excalidraw diagram showing a deployment pipeline from GitHub to CI, staging, production, and monitoring, then open it in fullscreen editing mode.')
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'text'):
                        print(block.text)

asyncio.run(main())
```

```typescript
import { openai } from '@ai-sdk/openai';
import { experimental_createMCPClient as createMCPClient } from '@ai-sdk/mcp';
import { generateText } from 'ai';

const client = await createMCPClient({
  transport: {
    type: 'http',
    url: session.mcp.url,
    headers: {
      'x-api-key': 'your-composio-api-key',
    },
  },
});

const tools = await client.tools();
const { text } = await generateText({
  model: openai('gpt-4o'),
  tools,
  messages: [{
    role: 'user',
    content: 'Create an Excalidraw diagram showing a deployment pipeline from GitHub to CI, staging, production, and monitoring, then open it in fullscreen editing mode.'
  }],
  maxSteps: 5,
});

console.log(`Agent: ${text}`);
```

## Why Use Composio?

### 1. AI Native Excalidraw MCP Integration

- Supports both Excalidraw MCP and direct API based integrations
- Structured, LLM-friendly schemas for reliable diagram creation and editing
- Rich coverage for creating scenes, adjusting the viewport, and launching fullscreen editing

### 2. Managed Auth

- No OAuth flow or API key setup needed for Excalidraw MCP because it uses no-auth access
- Composio still gives you a central place to manage agent sessions and tool access
- No hard-coded credentials, no token refresh work, and no auth plumbing to maintain

### 3. Agent Optimized Design

- Tools are shaped for AI agents to create diagrams from plain language prompts
- LLM-friendly inputs help agents place elements, update scenes, and control camera view more reliably
- Comprehensive execution logs so you can see what diagram action ran, when, and for which user

### 4. Enterprise Grade Security

- Fine-grained RBAC so you control which agents and users can access Excalidraw MCP
- Scoped access to Excalidraw MCP tools, including scene creation and viewport operations
- Full audit trail of agent actions to support review, debugging, and compliance

## Use Excalidraw MCP with any AI Agent Framework

Choose a framework you want to connect Excalidraw MCP with:

- [ChatGPT Work](https://composio.dev/toolkits/excalidraw_mcp/framework/chatgpt)
- [Claude Cowork](https://composio.dev/toolkits/excalidraw_mcp/framework/claude-cowork)

## Related Toolkits

- [Figma](https://composio.dev/toolkits/figma) - Figma is a collaborative interface design tool for teams and individuals. It streamlines design workflows with real-time collaboration and easy sharing.
- [Abyssale](https://composio.dev/toolkits/abyssale) - Abyssale is a creative automation platform for generating images, videos, GIFs, PDFs, and HTML5 content programmatically. It streamlines and scales visual content production for marketing, design, and operations teams.
- [Alttext ai](https://composio.dev/toolkits/alttext_ai) - AltText.ai is a service that generates alt text for images automatically. It helps boost accessibility and SEO for your visual content.
- [Bannerbear](https://composio.dev/toolkits/bannerbear) - Bannerbear is an API-driven platform for generating images and videos automatically at scale. It helps businesses create custom graphics, social visuals, and marketing assets using powerful templates.
- [Canva](https://composio.dev/toolkits/canva) - Canva is a drag-and-drop design suite for creating professional graphics, presentations, and marketing materials. It makes it easy for anyone to design with beautiful templates and a vast library of elements.
- [Claid ai](https://composio.dev/toolkits/claid_ai) - Claid.ai delivers AI-driven image editing APIs for tasks like background removal, upscaling, and color correction. It helps automate and enhance image workflows with powerful, developer-friendly tools.
- [Cloudinary](https://composio.dev/toolkits/cloudinary) - Cloudinary is a cloud-based platform for managing, uploading, and transforming images and videos. It streamlines media workflows and delivers optimized assets globally.
- [Cults](https://composio.dev/toolkits/cults) - Cults is a digital marketplace for 3D printing models, connecting designers and makers. It lets creators share, sell, and discover a huge variety of printable designs easily.
- [DeepImage](https://composio.dev/toolkits/deepimage) - DeepImage is an AI-powered image enhancer and upscaler. Get higher-quality images with just a few clicks.
- [Dreamstudio](https://composio.dev/toolkits/dreamstudio) - DreamStudio is Stability AI’s platform for generating and editing images with AI. It lets you easily turn ideas into stunning visuals, fast.
- [Dynapictures](https://composio.dev/toolkits/dynapictures) - Dynapictures is a cloud-based platform for generating personalized images at scale. Instantly create hundreds of custom visuals using your data sources, like Google Sheets.
- [Fal.ai](https://composio.dev/toolkits/fal_ai) - Fal.ai is a generative media platform offering 600+ AI models for images, video, voice, and audio. Developers use Fal.ai for fast, scalable access to cutting-edge generative AI tools.
- [Gamma](https://composio.dev/toolkits/gamma) - Gamma is an AI-powered platform for making beautiful, interactive presentations and documents. It lets anyone create and share engaging decks with minimal effort.
- [Html to image](https://composio.dev/toolkits/html_to_image) - Html to image converts HTML and CSS into images or captures web page screenshots. Instantly generate visuals from code or web content—no manual screenshots needed.
- [Imagior](https://composio.dev/toolkits/imagior) - Imagior is an AI-powered image generation platform that lets you create and customize images using dynamic templates and APIs. Perfect for businesses and creators needing fast, scalable visuals without design hassle.
- [Imejis io](https://composio.dev/toolkits/imejis_io) - Imejis io is an API-based image generation platform with powerful customization and template support. It lets you create and modify images in seconds, no manual design work required.
- [Imgix](https://composio.dev/toolkits/imgix) - Imgix is a real-time image processing and delivery service for developers. It helps you optimize, transform, and deliver images efficiently at any scale.
- [Kraken io](https://composio.dev/toolkits/kraken_io) - Kraken.io is an image optimization and compression platform. It helps you shrink image file sizes while keeping visual quality intact.
- [Logo dev](https://composio.dev/toolkits/logo_dev) - Logo.dev is an API and database for high-resolution company logos and brand metadata. Instantly fetch official logos from any domain without scraping or manual searching.
- [Mermaid Chart MCP](https://composio.dev/toolkits/mermaid_chart_mcp) - Mermaid Chart MCP is a no-auth MCP server for validating Mermaid syntax and rendering diagrams as SVG. Use it to preview, zoom, and iterate on diagrams quickly without wiring up custom rendering code.

## Frequently Asked Questions

### Do I need my own developer credentials to use Excalidraw MCP with Composio?

No. Excalidraw MCP uses no-auth access, so you don't need to configure OAuth credentials, API keys, or developer tokens. Just create a Composio Tool Router session and your agent can start creating and editing Excalidraw diagrams.

### Can I use multiple toolkits together?

Yes! Composio's Tool Router enables agents to use multiple toolkits. [Learn more](https://docs.composio.dev/tool-router/overview).

### Is Composio secure?

Composio is SOC 2 and ISO 27001 compliant with all data encrypted in transit and at rest. [Learn more](https://trust.composio.dev).

### What if the API changes?

Composio maintains and updates all toolkit integrations automatically, so your agents always work with the latest API versions.

---
[See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)