Canvas Mcp

Canvas MCP Server

MCP server for Canvas LMS with up to 101 tools and 8 agent skills. Designed for Claude Desktop, Cursor, Codex, Windsurf, and 40+ other agents; setup and capabilities vary by client.

npx skills add vishalsachdev/canvas-mcp

For AI Agents

Canvas MCP provides up to 101 tools for interacting with Canvas LMS; the default profile registers fewer, and optional feature-gated tools can raise the total to 101. Tools are organized by user type:

Quick Reference

Course identifiers: Canvas ID (12345), course code (badm_350_120251_246794), or SIS ID

Cannot do: Create/delete courses, modify course settings, access other users' data

Rate limits: ~700 requests/10 min. Use max_concurrent=5 for bulk operations.

Full documentation: AGENTS.md | tools/TOOL_MANIFEST.json | tools/README.md

Overview

The Canvas MCP Server bridges the gap between AI assistants and Canvas Learning Management System, providing role-specific workflows for students, educators, learning designers, and developers. Built on the Model Context Protocol (MCP), it is designed for MCP-compatible clients; setup and supported capabilities vary by client.

Latest Release: v1.11.0

Released: August 2026 | Full Changelog | All Releases

A protocol-correctness release. Every change here is about a client being able to tell what actually happened when it calls a tool. One change is breaking and one alters response shape — read both before upgrading.

• Breaking: send_peer_review_reminders is now send_peer_review_inbox_messages (#303). The old name implied it invoked Canvas's native reminder action; it does not, it sends ordinary Canvas Inbox messages, and the name now says so. The tool also resolves the course and requires manage_grades before previewing or sending, failing closed when the permission cannot be verified. Thanks @jonespm for catching the mismatch
• Tool failures now set MCP isError: true (#270). Previously a Canvas error and an empty-but-successful result were indistinguishable to a client: both came back as an ordinary result. Errors keep their existing text or structured payload, they are simply flagged correctly now
• Response-shape change: string-returning tools no longer duplicate their payload (#271). 91 of the registered tools were emitting the same value twice, once as text content and again under an information-free structuredContent.result. Dictionary-returning tools keep their structured schemas. If a client reads structuredContent.result for a string-returning tool, switch it to the text content
• FastMCP dependency floor raised to 3.4.7 (#293), picking up upstream fixes for Azure scope fallback, deterministic transformed-tool schemas, trusted OAuth metadata/JWKS proxies, and private_key_jwt audience validation

For Students 👨‍🎓

Get AI-powered assistance with:

• Tracking upcoming assignments and deadlines
• Monitoring your grades across all courses
• Managing peer review assignments
• Accessing course content and discussions
• Organizing your TODO list

→ Get Started as a Student

For Educators 👨‍🏫

Enhance your teaching with:

• Assignment and grading management
• Student analytics and performance tracking
• Discussion and peer review facilitation
• Privacy controls designed to support FERPA-conscious workflows
• Bulk messaging and communication tools

→ Get Started as an Educator

For Learning Designers 🎨

AI-powered course design and quality assurance:

• Course scaffolding — Build entire course structures from specs, templates, or by cloning existing courses
• Quality audits — Pre-semester QC checks for structure, content, publishing, and completeness
• Accessibility review — 20-check WCAG-oriented scanner (headings, tables, scope, contrast, alt text, links, captions, DesignPLUS migration), prioritized reports, guided remediation, and verification
• Course structure analysis — Full module→items tree in a single call for rapid course review

3 dedicated skills (canvas-course-qc, canvas-accessibility-auditor, canvas-course-builder) plus the get_course_structure tool.

🤖 Agent Skills

Pre-built workflow recipes that teach AI agents how to use Canvas MCP tools effectively. Available for 40+ coding agents via skills.sh, or as Claude Code-specific slash commands.

Install via skills.sh (Any Agent)

npx skills add vishalsachdev/canvas-mcp

This launches an interactive picker to install skills into your agent of choice (Claude Code, Cursor, Codex, OpenCode, Cline, Zed, and many more).

Install a specific skill:

npx skills add vishalsachdev/canvas-mcp -s canvas-week-plan

Claude Code Slash Commands

If you use Claude Code, the same workflows are also available as slash commands:

You: /canvas-morning-check CS 101
Claude: [Generates comprehensive course status report]

You: /canvas-week-plan
Claude: [Shows prioritized weekly assignment plan]

Claude Code skills are located in .claude/skills/ and can be customized for your workflow.

Want a custom skill? Submit a request describing your repetitive workflow!

🔒 Privacy & Data Protection

For Educators: FERPA-Conscious Data Handling

Canvas MCP provides optional privacy controls that can support an institution's FERPA obligations. Compliance still depends on your deployment, configuration, institutional policy, and AI provider:

• Response anonymization converts supported identity fields to consistent anonymous IDs (Student_xxxxxxxx)
• Email masking and supported PII-pattern filtering in discussion posts and submissions
• Local server deployment with configurable privacy controls (ENABLE_DATA_ANONYMIZATION=true)
• Privacy-conscious analytics: Ask "Which students need support?" while reducing the identity data returned to the AI client
• De-anonymization mapping tool for faculty to correlate anonymous IDs with real students locally

When ENABLE_DATA_ANONYMIZATION=true is enabled, supported identity fields are anonymized before tool results reach the AI client. Review the Educator Guide and your institution's requirements before using student data.

For Students: Data Scope & Privacy

• Canvas-scoped access: Student-specific tools use Canvas's "self" endpoints; shared course-content tools follow the permissions Canvas grants your account
• No shared-server credential storage: Local mode reads your Canvas token from your own .env. In authenticated institutional HTTP deployments, each request supplies the user's Canvas token and the server does not store it.
• No built-in product analytics: Canvas MCP does not add telemetry; Canvas and your AI client still apply their own logging and data policies
• Optional anonymization: Student tools are scoped to your own Canvas data, but your AI client's privacy policy still applies

Hosted Server (Retired)

The public hosted server (mcp.illinihunt.org) has been retired. A public MCP endpoint without an access gate isn't safe to operate — it would expose the built-in code-execution tool — so the supported path is local installation below.

The HTTP/streamable transport itself remains fully supported for self-hosting behind your own authentication (canvas-mcp-server --transport streamable-http). Running a shared, authenticated instance for your institution? See deploy/azure/ for a production-tested deployment specification (Azure App Service + Entra ID platform auth, per-user Canvas tokens) with sample workflow and config templates.

Prerequisites (Local Installation)

• Python 3.10+ - Required for modern features and type hints
• Canvas API Access - API token and institution URL
• MCP Client - An MCP-compatible client (Claude Desktop, Cursor, Zed, Windsurf, Continue, etc.); setup and capabilities vary by client

Supported MCP Clients

Canvas MCP is designed for MCP-compatible clients, including Claude Desktop, Cursor, Zed, Windsurf, Continue, Replit, and Copilot Studio. Setup details and supported capabilities vary by client.

Canvas MCP uses documented Canvas API patterns such as a User-Agent header and per_page pagination. It is intended for Canvas Cloud and compatible self-hosted instances.

Install as a Claude Desktop Extension (easiest)

If you use Claude Desktop, you can install Canvas MCP with one click — no terminal, no config-file editing:

1. Download canvas-mcp.mcpb from the latest release.
2. Double-click the file (or drag it into Claude Desktop → Settings → Extensions).
3. When prompted, enter your Canvas API URL — this must include the /api/v1 path (e.g. https://canvas.youruniversity.edu/api/v1) — and your Canvas API token (Canvas → Account → Settings → New Access Token — some institutions issue these by request form instead, see below). The token is stored in your OS keychain.

The extension runs the server locally and calls Canvas with your own token, so requests use that token's Canvas permissions. Canvas and your AI client may retain their own activity records. Requires Python 3.10+ (the bundled runtime manages dependencies automatically). For other clients, or to run from source, use the manual setup below.

Local Installation

1. Install Dependencies

# (Recommended) Use a dedicated virtualenv so the MCP binary is in a stable location
python3 -m venv .venv
. .venv/bin/activate

# Install the package editable
pip install -e .

2. Configure Environment

# Copy environment template
cp env.template .env

# Edit with your Canvas credentials
# Required: CANVAS_API_TOKEN, CANVAS_API_URL

Get your Canvas API token from: Canvas → Account → Settings → New Access Token

Some institutions gate token creation. Where self-service is disabled, the "New Access Token" button is missing or errors out, and tokens are issued through an IT request form instead. Check your institution's IT knowledge base before concluding that API access is unavailable to you.

University of Illinois Urbana-Champaign works this way for everyone — students and instructors alike. Request a token with the Canvas API Token Request form (NetID login required). Once it is approved:

1. Go to Canvas → Account → Settings → Approved Integrations, find the new token, click Activate, and refresh the page.
2. Retrieve the token value from the U of I Box link Technology Services sends you.

As of August 2026, all new Illinois tokens carry a 30-day expiration (an upstream Instructure requirement). Expiry is not monitored or announced, and expired tokens are removed without notice — request the replacement before the current one lapses. Full details: Answers KB 150325.

Students elsewhere: if you see "There is a limit to the number of access tokens you can create" or cannot find the token creation option, contact your institution's Canvas administrator or IT support department to request API access.

3. MCP Client Configuration

Canvas MCP is designed for MCP-compatible clients. Below are configuration examples for popular clients; exact setup and capabilities vary by client:

{
  "mcpServers": {
    "canvas-api": {
      "command": "/absolute/path/to/canvas-mcp/.venv/bin/canvas-mcp-server"
    }
  }
}

{
  "mcpServers": {
    "canvas-api": {
      "command": "/absolute/path/to/canvas-mcp/.venv/bin/canvas-mcp-server"
    }
  }
}

{
  "context_servers": {
    "canvas-api": {
      "command": {
        "path": "/absolute/path/to/canvas-mcp/.venv/bin/canvas-mcp-server",
        "args": []
      }
    }
  }
}

{
  "mcpServers": {
    "canvas-api": {
      "command": "/absolute/path/to/canvas-mcp/.venv/bin/canvas-mcp-server"
    }
  }
}

{
  "mcpServers": {
    "canvas-api": {
      "command": "/absolute/path/to/canvas-mcp/.venv/bin/canvas-mcp-server"
    }
  }
}

Windows users: Replace forward slashes with backslashes in paths (e.g., C:\Users\YourName\canvas-mcp\.venv\Scripts\canvas-mcp-server.exe)

Verification

Test your setup:

# Test Canvas API connection
canvas-mcp-server --test

# View configuration
canvas-mcp-server --config

# Start server (for manual testing)
canvas-mcp-server

Available Tools

The Canvas MCP Server provides a set of tools for interacting with the Canvas LMS API. These tools are organized into logical categories for better discoverability and maintainability.

Tool Categories

Student Tools (New!)

• Personal assignment tracking and deadline management
• Grade monitoring across all courses
• TODO list and peer review management
• Submission status tracking

Shared Tools (Both Students & Educators)

1. Course Tools - List and manage courses, get detailed information, generate summaries with syllabus content
2. Discussion & Announcement Tools - Manage discussions, announcements, and replies
3. Page & Content Tools - Access pages, modules, and course content

Educator Tools 4. Assignment Tools - Handle assignments, submissions, and peer reviews with analytics 5. Rubric Tools - List rubrics, associate with assignments, and grade submissions (including bulk_grade_submissions for efficient batch grading). Note: Create/update rubrics via Canvas web UI due to API limitations. 6. User & Enrollment Tools - Manage enrollments, users, and groups 7. Analytics Tools - View student analytics, assignment statistics, and progress tracking 8. Messaging Tools - Send messages and announcements to students

Developer Tools 9. Discovery Tools - Search registered MCP tools and code execution API operations with search_canvas_tools; list code execution modules with list_code_api_modules 10. Code Execution Tools - Execute TypeScript code with execute_typescript so bulk item processing can stay out of the model's context

📖 View Full Tool Documentation for detailed information about the available tools.

Code Execution API

For bulk operations (30+ items), Canvas MCP supports TypeScript code execution. Process bulk operations locally without loading every item into the model’s context.

Use search_canvas_tools to discover available operations, then execute_typescript to run them locally. The default sandbox applies time, memory, environment, and best-effort network controls, but it is not a complete security boundary; use stronger external isolation when untrusted code or strict egress control is required (see issue #157). Works on macOS, Linux, and Windows.

import { bulkGrade } from './canvas/grading/bulkGrade';

await bulkGrade({
  courseIdentifier: "60366",
  assignmentId: "123",
  gradingFunction: (submission) => {
    const notebook = submission.attachments?.find(f =>
      f.filename.endsWith('.ipynb')
    );
    if (!notebook) return null;
    return { points: 100, comment: "Great work!" };
  }
});

Usage

MCP clients start the server automatically. Just ask naturally:

• "What's due this week?" / "Show my grades" / "What peer reviews do I need?"
• "Who hasn't submitted Assignment 3?" / "Send reminders to missing students"

Quick start guides: Student | Educator | Real-World Workflows | Troubleshooting

Documentation

• Tool Documentation — Reference for the available tools, including optional feature-gated tools
• Student Guide — Getting started as a student
• Educator Guide — FERPA considerations and educator workflows
• Bulk Grading Example — Batch grading walkthrough
• Development Guide — Architecture and contributing

Troubleshooting

If you encounter issues:

1. Server Won't Start - Verify your Local Installation setup: .env file, virtual environment path, and dependencies
2. Authentication Errors - Check your Canvas API token validity and permissions
3. Connection Issues - Verify Canvas API URL correctness and network access
4. Debugging - Check your MCP client's console logs (e.g., Claude Desktop's developer console) or run server manually for error output

Security

Runtime security and privacy controls:

Optional anonymization for FERPA-conscious educator workflows: ENABLE_DATA_ANONYMIZATION=true. See Educator Guide for scope and configuration details.

Publishing

Published to PyPI, MCP Registry, and skills.sh (agent skills). Releases are automated via GitHub Actions — tag a version (git tag vX.Y.Z && git push origin vX.Y.Z) and CI handles the rest.

Contributing

Contributions are welcome! Feel free to:

• Submit issues for bugs or feature requests
• Create pull requests with improvements
• Share your use cases and feedback

Contributors

Thanks to everyone who has contributed to Canvas MCP:

• @DomBarker99 — read_course_file tool for remote MCP deployments (#90)
• @Promithius-DR — Role-based tool filtering and tool annotations (#84)
• @Metzpapa — File download and listing tools (#75)
• @JCSnap — Student tool bug fixes (#72, #73)

License

This project is licensed under the MIT License - see the LICENSE file for details.

Created by Vishal Sachdev