canvas-mcp
Provides 47 tools for instructors to manage Canvas LMS courses, including reading rosters, drafting and creating assignments, building modules, grading submissions, posting announcements, and retrieving gradebook data via the Canvas REST API.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@canvas-mcp Which students haven't submitted Essay 2 yet, and when is it due?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
canvas-mcp
Run your Canvas course from an AI assistant.
canvas-mcp is an MCP server that gives Claude,
Cursor, VS Code, or any other MCP-capable assistant 47 tools for Canvas LMS —
reading your roster, drafting assignments, building modules, grading submissions,
posting announcements, and pulling the whole gradebook into one table.
It is written for instructors, not Canvas administrators. Everything it does, it does as you, with your token, inside the courses you already teach.
You: "Which students haven't submitted Essay 2 yet, and when is it due?"
"Draft a Week 9 module on Bonhoeffer with a reading page and a discussion,
but leave it unpublished so I can look first."
"Give everyone who submitted Lab 3 full marks with the comment 'Nice work'."Table of contents
Related MCP server: Canvas MCP Server
What you get
47 tools | across diagnostics, courses, people, assignments, grading, content, and communication |
Three safety tiers | read-only always on; writes on by default; deletes off by default |
Tools you disable are never published | a withheld tool isn't in the model's tool list at all — it can't be called and it costs no context |
Bounded output | big payloads are slimmed to the fields that matter and truncated with an explicit notice, so one |
Readable text, not raw HTML | syllabi, pages, and discussion threads come back as plain text with paragraph breaks intact |
Optional PII redaction |
|
Retries that understand Canvas | Canvas signals rate limiting with a |
A | tells you exactly which of base-url / token / permissions / course-id is wrong, instead of a generic 401 |
No vendor lock-in | pure |
Quick start (5 minutes)
1. Install
Pick whichever matches how you already run Python.
With uv (recommended — no virtualenv to manage):
uvx --from git+https://github.com/zhenghh04/canvas-mcp canvas-mcp doctorWith pip:
pip install git+https://github.com/zhenghh04/canvas-mcpFrom a clone (if you want to modify it):
git clone https://github.com/zhenghh04/canvas-mcp
cd canvas-mcp
pip install -e ".[dev]"
pytest # 163 tests, all offline — none of them touch a real courseRequires Python 3.10 or newer.
2. Get a Canvas API token
You do not need an administrator, and you do not need to register an app.
Log in to Canvas in a browser.
Click Account (left sidebar) → Settings.
Scroll to Approved Integrations.
Click + New Access Token.
Purpose:
canvas-mcp. Expiry: leave blank for no expiry, or set a date — if you set one, note it, because an expired token looks exactly like a wrong token.Click Generate Token.
Copy the token now. Canvas shows it exactly once. If you lose it, delete the entry and make a new one.
The token carries all your Canvas permissions — in every course you teach, and every course you take. Treat it like your password. See Student privacy and FERPA.
Locked down? Some institutions disable self-service tokens. If you don't see + New Access Token, ask your Canvas admin for a token or for the setting to be enabled for faculty.
3. Find your course id
Open the course in Canvas and look at the URL:
https://yourschool.instructure.com/courses/12345
^^^^^
this is the course idSetting a default course id is optional but makes every conversation shorter — you
can say "the roster" instead of "the roster for course 12345". You can always
override it per call, and canvas_list_courses will show you all of them.
4. Tell the server about them
Two settings are required: where your Canvas lives and your token.
You can supply them three ways. Later entries do not override earlier ones —
an already-set environment variable always wins, so your MCP client's env
block beats any .env file.
Priority | Source |
1 | Real environment variables (including your MCP client's |
2 |
|
3 |
|
4 |
|
The last one is usually what you want, because it works no matter which directory your assistant starts in:
mkdir -p ~/.config/canvas-mcp
cat > ~/.config/canvas-mcp/.env <<'EOF'
CANVAS_BASE_URL=https://yourschool.instructure.com
CANVAS_API_TOKEN=paste-your-token-here
CANVAS_DEFAULT_COURSE_ID=12345
EOF
chmod 600 ~/.config/canvas-mcp/.envThat chmod matters — the file now contains a credential.
See env.example for every available setting, annotated.
5. Check it works
canvas-mcp doctorA healthy run looks like:
canvas-mcp 0.2.0
[OK ] CANVAS_BASE_URL set — https://yourschool.instructure.com
[OK ] CANVAS_API_TOKEN set
[OK ] Token authenticates — Ada Lovelace (id 10665)
[OK ] Teacher enrollments visible — 1 active course(s)
12345 Introduction to Analytical Engines (CS-101)
[OK ] CANVAS_DEFAULT_COURSE_ID resolves — Introduction to Analytical Engines (CS-101)
42 tools would be published (writes=on, destructive=off). Run `canvas-mcp tools` for the list.If any line is wrong, doctor says what to fix. See
Troubleshooting.
6. Connect your AI assistant
One command:
claude mcp add canvas -- canvas-mcp serveOr add to .mcp.json in your project (or ~/.claude.json for every project):
{
"mcpServers": {
"canvas": {
"command": "canvas-mcp",
"args": ["serve"],
"env": {
"CANVAS_BASE_URL": "https://yourschool.instructure.com",
"CANVAS_DEFAULT_COURSE_ID": "12345"
}
}
}
}Note that the token is deliberately not in this file — .mcp.json is the kind
of file that gets committed to git by accident. Leave CANVAS_API_TOKEN in
~/.config/canvas-mcp/.env.
Edit claude_desktop_config.json:
macOS —
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows —
%APPDATA%\Claude\claude_desktop_config.jsonLinux —
~/.config/Claude/claude_desktop_config.json
{
"mcpServers": {
"canvas": {
"command": "canvas-mcp",
"args": ["serve"],
"env": {
"CANVAS_BASE_URL": "https://yourschool.instructure.com",
"CANVAS_DEFAULT_COURSE_ID": "12345"
}
}
}
}Then fully quit and reopen Claude Desktop — reloading the window is not enough.
If canvas-mcp isn't found, Claude Desktop doesn't inherit your shell PATH. Use
an absolute path (which canvas-mcp will tell you), or use uvx:
{
"mcpServers": {
"canvas": {
"command": "uvx",
"args": ["--from", "git+https://github.com/zhenghh04/canvas-mcp", "canvas-mcp", "serve"]
}
}
}Settings → MCP → Add new MCP server, or edit ~/.cursor/mcp.json:
{
"mcpServers": {
"canvas": {
"command": "canvas-mcp",
"args": ["serve"],
"env": { "CANVAS_BASE_URL": "https://yourschool.instructure.com" }
}
}
}Create .vscode/mcp.json:
{
"servers": {
"canvas": {
"type": "stdio",
"command": "canvas-mcp",
"args": ["serve"],
"env": { "CANVAS_BASE_URL": "https://yourschool.instructure.com" }
}
}
}Standard stdio MCP server:
canvas-mcp serve # stdio, the defaultOr serve over HTTP for a remote or multi-client setup:
canvas-mcp serve --transport http --host 127.0.0.1 --port 8900Bind to 127.0.0.1 unless you have put real authentication in front of it.
This server has no auth of its own: anyone who can reach the port is acting as you,
in your courses, with your token.
Ready-made config snippets live in examples/.
Safety model
Three tiers. A tool you don't enable is never registered — the model cannot see it, cannot call it, and it costs nothing in context.
Tier | Default | Controlled by | What's in it |
read | always on | — | 24 tools. Rosters, assignments, submissions, pages, the gradebook. Never changes anything. |
write | on |
| 18 tools. Create and edit assignments, pages, modules; post grades; send announcements and messages. |
destructive | off |
| 5 tools. Delete assignments, pages, modules; remove enrollments; arbitrary |
The destructive flag cannot bypass the write gate: with CANVAS_ENABLE_WRITES=0,
setting CANVAS_ALLOW_DESTRUCTIVE=1 publishes nothing.
Three postures worth knowing:
# Read-only. Nothing can change. Good for a first week, or for a shared setup.
CANVAS_ENABLE_WRITES=0
# Default. Author and grade freely; nothing can be deleted.
# (this is what you get with no settings at all)
# Full. Only turn this on for a specific cleanup task, then turn it back off.
CANVAS_ALLOW_DESTRUCTIVE=1Beyond the tiers, every mutating tool says so in its own description —
MUTATES the course, MUTATES STUDENT RECORDS, NOTIFIES PEOPLE, IRREVERSIBLE —
because that text is what the model actually reads when deciding whether to ask you
first. The server's instructions tell the assistant to get explicit go-ahead before
any of them.
Some further guarantees, each with a test behind it:
Authoring is unpublished by default.
canvas_create_assignment,canvas_create_page, andcanvas_create_moduleall create drafts. Students see nothing until you publish.Your token never reaches the file-storage host. Canvas uploads go to an S3 / InstFS URL with its own pre-signed credentials; the bearer token is stripped.
Student filenames are sanitised.
canvas_download_submissionswrites attachments to disk, and../../.ssh/authorized_keysis a perfectly legal Canvas filename.Messages don't leak the recipient list.
canvas_message_studentssends individually by default, not as a group conversation.Errors are errors. A bug in this server raises; only genuine Canvas failures are converted into a readable
ERROR: …string for the model.
The 47 tools
Legend: (blank) read-only · ! write · !! destructive.
Run canvas-mcp tools to see exactly what your configuration publishes.
Diagnostics
Tool | What it does | |
| Check connectivity, identity, and which tiers are enabled. Call this first. | |
| Escape hatch: | |
|
| Escape hatch: |
Courses
Tool | What it does | |
| List the courses you can see. | |
| One course: teachers, student count, syllabus as plain text. | |
| Sections with enrollment counts. | |
|
| Edit course settings (name, dates, publish state). |
|
| Replace the syllabus body. |
People
Tool | What it does | |
| The roster. | |
| Enrollments including the | |
|
| Add a user to the course. |
|
| Remove someone from the course. |
Assignments
Tool | What it does | |
| Assignments with due dates and needs-grading counts. | |
| One assignment, description rendered to plain text. | |
| Gradebook categories and their weights. | |
|
| Create a gradebook category. |
|
| Create an assignment (unpublished by default). |
|
| Edit an existing assignment. |
|
| Delete an assignment. |
Grading
Tool | What it does | |
| Status, score, timestamps, lateness for an assignment. | |
| One student's submission: body text, attachments, comments. | |
| The whole gradebook as one student × assignment table. | |
| Download every file attachment for an assignment. | |
|
| Post a grade and/or a comment. |
|
| Post many grades to one assignment at once. |
Content
Tool | What it does | |
| Wiki page titles and url slugs. | |
| One page's body as plain text. | |
| The course outline, optionally with items. | |
| Quizzes in a course. | |
| Files uploaded to a course. | |
| Download one course file. | |
|
| Create a wiki page (unpublished by default). |
|
| Edit a wiki page. |
|
| Create a module (unpublished by default). |
|
| Edit or publish a module. |
|
| Add a page / assignment / quiz / link to a module. |
|
| Upload a local file into Files. |
|
| Delete a wiki page. |
|
| Delete a module. |
Communication
Tool | What it does | |
| Announcements, newest first, with their text. | |
| Discussion topics. | |
| A topic with its full reply thread as plain text. | |
| Calendar events, optionally with assignment due dates. | |
|
| Post an announcement — students are notified. |
|
| Create a discussion topic. |
|
| Add an event to the course calendar. |
|
| Send a Canvas inbox message. |
Full parameter-by-parameter reference: docs/TOOLS.md.
Configuration reference
Every setting is an environment variable. All are optional except the first two.
Required
Variable | Example | Notes |
|
| No trailing slash needed; one is stripped. Do not include |
|
| From Account → Settings → New Access Token. |
Convenience
Variable | Default | Notes |
| — | Used whenever a tool's |
| — | Path to a |
|
| Where downloaded files and submissions land. |
Safety
Variable | Default | Notes |
|
|
|
|
|
|
|
|
|
Trimming the tool surface
Fewer tools means less context spent and fewer ways to go wrong.
Variable | Example | Notes |
|
| Comma-separated. Groups: |
|
| Strict allowlist. Only these, and only if their tier is enabled. |
|
| Denylist, applied after everything else. |
An allowlist can never bypass a tier gate. Listing canvas_delete_page in
CANVAS_TOOLS does nothing unless CANVAS_ALLOW_DESTRUCTIVE=1.
Limits and performance
Variable | Default | Notes |
|
| Seconds per API request. |
|
| Seconds for file uploads. |
|
| Refuse larger local files. |
|
| Canvas page size. |
|
| Pagination cap. Results past it are marked |
|
| Response size cap, with an explicit truncation notice. |
|
| Attempts on rate limits and 5xx. |
Command-line interface
canvas-mcp # same as `serve` — stdio MCP server
canvas-mcp serve # stdio (what MCP clients launch)
canvas-mcp serve --transport http --host 127.0.0.1 --port 8900
canvas-mcp doctor # diagnose configuration and permissions
canvas-mcp tools # list what this configuration publishes, and what it withholds
canvas-mcp config # show resolved settings (token redacted)canvas-mcp config prints "api_token": "set (70 chars)" — never the token itself.
serve deliberately starts even when misconfigured, printing a warning to
stderr. An MCP client that sees its server exit immediately reports only "broken
pipe", which tells you nothing; a running server can answer canvas_auth_status
with an actual explanation.
Recipes
Things that work well. More in docs/RECIPES.md.
Triage before office hours
"Who hasn't submitted Essay 2? For each, tell me whether they've submitted the previous two assignments."
Build a week
"Create an unpublished module called 'Week 9 — Bonhoeffer', add a page with the reading questions below, and a discussion topic due Friday 11:59pm. Don't publish anything."
Grade a batch
"List submissions for Lab 3. For everyone who submitted on time with a file attached, give 10/10 and the comment 'Received, nice work.' Show me the list before you post anything."
Catch grading drift
"Pull the gradebook. Which assignments still have ungraded submissions, and which students are more than one standard deviation below the mean overall?"
Sync a syllabus
"Here's my updated syllabus as markdown. Replace the Canvas syllabus with it, preserving the existing course-policies section at the bottom."
Read the room
"Summarise the Week 4 discussion thread. What are the three most common misunderstandings, and which students should I follow up with?"
A habit worth forming: ask for the plan before the action. "Show me what you'd post, then wait" costs one extra turn and catches the wrong-assignment-id mistake before it reaches 30 students.
Student privacy and FERPA
This server reads real student data. A few things are worth being deliberate about.
Your token is your whole Canvas account. Not just one course — every course you
teach and every course you take. Keep it in a chmod 600 file, never in a
git-tracked config, and revoke it from Account → Settings if it leaks.
Student data flows to your AI provider. When the assistant reads a roster or a submission, that text goes to whoever runs the model. Check whether your institution has a data-processing agreement covering that provider before putting student work through it. This is the single most important thing on this page.
CANVAS_REDACT_PII=1 helps, partially. It replaces emails, login ids, and SIS
ids with stable anon-<hash> values — stable so the model can still correlate rows,
non-reversible so the identifier itself doesn't travel. Names are deliberately not
redacted, because an assistant that can't say "follow up with Dana" isn't much
use. If names are the concern, redaction is not the answer — don't route the roster
through a model at all.
Downloads land on your disk. canvas_download_submissions writes student work
to CANVAS_DOWNLOAD_DIR. That's a FERPA-relevant directory; treat it like one, and
clean it up.
Keep the destructive tier off. Grades and enrollments are student records. The default posture lets the assistant write grades (recoverable, visible in the gradebook history) but not remove enrollments (not recoverable in the same way).
More detail: docs/SAFETY.md.
Troubleshooting
Run canvas-mcp doctor first — most of these it will name directly.
The server couldn't find your token. Check, in order:
canvas-mcp config— which env file did it load? Ifenv file: (none), it found no file at any of the four locations.Your MCP client may start the server in a different working directory, so a
./.envwon't be found. Use~/.config/canvas-mcp/.env.Make sure the file has no quotes and no spaces around
=:CANVAS_API_TOKEN=7~abc— notCANVAS_API_TOKEN = "7~abc".
The token is wrong, revoked, or expired. Canvas tokens can have an expiry date set at creation, and an expired token returns exactly the same 401 as a typo'd one.
Generate a fresh one at Account → Settings → + New Access Token.
Also confirm CANVAS_BASE_URL points at the tenant the token came from — a valid
token for school-a.instructure.com is a 401 at school-b.instructure.com.
Two different things wear this status code in Canvas.
Rate limiting. The body says "Rate Limit Exceeded". The server detects this and retries with backoff; if you still see it, you're hammering the API — raise
CANVAS_TIMEOUTand make fewer, larger requests.Real permission denied. You're not a teacher in that course, or your role lacks the specific permission (some institutions restrict
message_studentsor enrollment changes even for teachers). Nothing this server can do; ask your Canvas admin.
Usually a wrong id, but Canvas also returns 404 instead of 403 for things you're not allowed to see, which is a deliberate anti-enumeration measure. So: check the id is right and that you're enrolled in that course as a teacher.
Canvas rejected the content. Common causes: a due date outside the course term, a
page title that collides with an existing one, points_possible on an assignment
whose grading type doesn't take points. The error message passes Canvas's own
explanation through.
Restart the client fully (Claude Desktop needs a real quit, not a window reload).
Run the exact command from your config by hand in a terminal. If
canvas-mcp: command not found, your client doesn't share your shellPATH— use an absolute path fromwhich canvas-mcp, or switch to theuvxform.Check the client's MCP logs. Claude Desktop:
~/Library/Logs/Claude/on macOS.
Run canvas-mcp tools. The WITHHELD section at the bottom lists every suppressed
tool and the exact reason — a tier gate, a group filter, an allowlist, or a
denylist.
Two separate caps. _truncated in a list means pagination stopped at
CANVAS_MAX_PAGES. A trailing truncation notice means the text hit
CANVAS_MAX_CHARS. Raise whichever one you hit — but they exist to protect your
context window, so prefer narrowing the request (one assignment, one section) over
raising the cap.
Check the file is under CANVAS_MAX_UPLOAD_MB (default 100) and that
CANVAS_UPLOAD_TIMEOUT is generous enough for your connection. Canvas uploads are a
three-step handshake through a separate storage host; a timeout in the middle leaves
nothing behind, so it's safe to retry.
FAQ
Do I need to be a Canvas administrator? No. A plain teacher account and a self-service access token. If your institution has disabled self-service tokens, you'll need an admin to issue one — that's the only admin involvement.
Will this work with my school's Canvas?
If it's Canvas and you can reach it over HTTPS, yes. It uses only the public REST
API v1. Self-hosted Canvas works too; just point CANVAS_BASE_URL at it.
Can it see other instructors' courses? Only what your own Canvas account can see. It has exactly your permissions — no more.
Can students use it? It'll run, but most tools need teacher permissions. It isn't designed for that.
Does it store anything?
No database, no cache, no telemetry. The only things written to disk are files you
explicitly download, into CANVAS_DOWNLOAD_DIR.
What if the AI grades something wrong?
Canvas keeps grade history — you can see and revert every change in the gradebook's
grade-change log. That's precisely why grading is in the write tier and not gated
behind destructive: it's recoverable. Still: review before posting.
Can I use it with a local model (Ollama, LM Studio)?
Yes, if your client speaks MCP. Note that the 47 tool descriptions are a meaningful
chunk of context for a small model — use CANVAS_TOOL_GROUPS to publish only what
you need.
Why doesn't it support Canvas's New Quizzes?
New Quizzes lives behind a separate API with different auth. canvas_list_quizzes
sees Classic Quizzes. PRs welcome.
Does it work with Canvas Free for Teachers?
Yes — https://canvas.instructure.com as your base URL.
Contributing
Issues and PRs welcome, particularly from instructors who hit something this doesn't
cover. See CONTRIBUTING.md.
git clone https://github.com/zhenghh04/canvas-mcp
cd canvas-mcp
pip install -e ".[dev]"
pytest # 163 tests, fully offline
ruff check .The test suite never contacts a real Canvas tenant — the fixture transport raises on any unexpected call, so a test that escapes fails loudly instead of mutating somebody's live course.
License
MIT. See LICENSE.
Not affiliated with or endorsed by Instructure. "Canvas" is their trademark.
Available Tools
42 toolscanvas_api_getA
Escape hatch: GET any Canvas REST endpoint without a dedicated tool.
Canvas publishes well over a thousand operations; the tools here cover the common teaching ones. Use this for the rest. Read-only by construction — it cannot issue a write even if asked to.
Args: path: path under /api/v1, e.g. "courses/12345/gradebook_history/days". A full URL is also accepted. params_json: optional JSON object of query parameters, e.g. '{"per_page": 20, "include[]": "submission"}'. max_chars: bound on the returned payload (0 = the server default).
Inputs: path (required), max_chars, params_json. Returns: result
canvas_auth_statusA
Check Canvas connectivity, identity, and which tool tiers are enabled.
Reveals no token material. Call this first whenever another Canvas tool
fails, or when a tool you expected is missing — the tools section
shows exactly what this server published and what a safety flag withheld.
Inputs: no named parameters. Returns: result
canvas_bulk_gradeA
Post many grades to one assignment at once. MUTATES STUDENT RECORDS.
Canvas processes this asynchronously and returns a Progress object, so the grades appear a few seconds later. There is no partial-failure report — read back with canvas_list_submissions to confirm.
A bulk write is the highest-consequence call in this server. Show the instructor the complete table of student ids, grades, and comments and get an explicit go-ahead; never assemble one from inference.
Args: assignment_id: numeric assignment id. grades_json: JSON object keyed by user id, e.g. '{"101": {"grade": "18", "comment": "Clear thesis."}, "102": {"grade": "15"}}'. A bare string value is accepted as the grade: '{"101": "18"}'. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: grades_json (required), assignment_id (required), course_id. Returns: result
canvas_create_assignmentA
Create an assignment. MUTATES the course.
Defaults to UNPUBLISHED so students do not see it until you publish — pass published=True only when the instructor says it is ready.
Args: name: assignment title. description: body HTML shown to students. points_possible: max score; omit for an ungraded assignment. due_at: ISO 8601 UTC, e.g. 2026-09-10T04:59:59Z. Canvas stores UTC, so an 11:59pm local deadline is not 23:59Z — convert first. unlock_at: ISO 8601 UTC; students cannot see it before this. lock_at: ISO 8601 UTC; submissions close after this. submission_types: comma-separated, from online_text_entry, online_upload, online_url, online_quiz, discussion_topic, media_recording, student_annotation, on_paper, external_tool, none. grading_type: points (default), percent, letter_grade, gpa_scale, pass_fail, not_graded. published: visible to students immediately (default False). assignment_group_id: group to file it under; see canvas_list_assignment_groups. omit_from_final_grade: True to score it without affecting the total. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: name (required), due_at, lock_at, course_id, +8 more. Returns: result
canvas_create_assignment_groupA
Create an assignment group (a gradebook category). MUTATES the course.
Args: name: group name, e.g. "Response Papers". group_weight: percentage of the final grade, if the course uses weighted groups. Omit for unweighted. position: 1-based slot in the group list; omit to append. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: name (required), position, course_id, group_weight. Returns: result
canvas_create_calendar_eventA
Create a calendar event on the course calendar. MUTATES the course.
Appears on every enrolled student's calendar. Good for class meetings, office hours, and guest lectures — not for assignment due dates, which belong on the assignment itself so the gradebook knows about them.
Args: title: event title. start_at: ISO 8601 UTC start, e.g. 2026-09-10T18:00:00Z. end_at: ISO 8601 UTC end; omit for a point-in-time event. description: event body (HTML allowed). location_name: room or place. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: title (required), start_at (required), end_at, course_id, +2 more. Returns: result
canvas_create_discussionA
Create a discussion topic. MUTATES the course.
Defaults to UNPUBLISHED so you can review it before students see it. Publishing a discussion notifies students who have announcements and discussions turned on.
Args: title: topic title. message: prompt body (HTML allowed). published: visible to students immediately (default False). require_initial_post: students must post before seeing replies. threaded: allow nested replies (default True). pinned: pin to the top of the discussions list. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: title (required), message (required), pinned, threaded, +3 more. Returns: result
canvas_create_moduleA
Create a course module. MUTATES the course.
A module is an empty container until you add items with canvas_create_module_item. Defaults to UNPUBLISHED.
Args: name: module title, e.g. "Week 3 — Coding agents". position: 1-based slot in the module list; omit to append at the end. published: visible to students immediately (default False). course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: name (required), position, course_id, published. Returns: result
canvas_create_module_itemA
Add an item to a module. MUTATES the course.
Which id field you need depends on item_type: Assignment / Quiz / Discussion / File -> content_id (the object's id) Page -> page_url (the slug) ExternalUrl / ExternalTool -> external_url SubHeader -> neither; title is the item
Args: module_id: numeric module id. title: item label shown in the module list. item_type: one of Assignment, Quiz, File, Page, Discussion, SubHeader, ExternalUrl, ExternalTool. content_id: id of the linked object, for the types that need one. page_url: page slug, for item_type=Page. external_url: target, for item_type=ExternalUrl or ExternalTool. position: 1-based slot within the module; omit to append. indent: nesting level, 0 for top level. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: title (required), item_type (required), module_id (required), indent, +5 more. Returns: result
canvas_create_pageA
Create a wiki page. MUTATES the course.
Defaults to UNPUBLISHED. Canvas derives the page's url slug from the
title; the returned url is what canvas_get_page and
canvas_update_page expect, not the numeric page_id.
Args: title: page title. body: page HTML. published: visible to students immediately (default False). front_page: make this the course home page. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: title (required), body, course_id, published, +1 more. Returns: result
canvas_download_fileA
Download one course file to local disk.
Writes to the machine running this server, not the user's laptop, if those differ.
Args: file_id: numeric file id (from canvas_list_files). dest_dir: destination folder; defaults to CANVAS_DOWNLOAD_DIR, or ./canvas-downloads. name: filename to save as; defaults to the Canvas display name.
Inputs: file_id (required), name, dest_dir. Returns: result
canvas_download_submissionsA
Download every file attachment for an assignment to a local folder.
Writes files to disk on the machine running this server. Each lands as
<dest_dir>/<assignment_id>/<user_id>__<filename> so the owner stays
attached to the file without putting a student name in a path.
FERPA: this copies student work out of Canvas onto local storage. Make sure the instructor knows where it is going and cleans it up afterwards.
Args: assignment_id: numeric assignment id. dest_dir: destination folder; defaults to CANVAS_DOWNLOAD_DIR, or ./canvas-downloads. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID. max_files: safety cap on how many files to pull (default 100).
Inputs: assignment_id (required), dest_dir, course_id, max_files. Returns: result
canvas_enroll_userA
Enrol a user in the course. MUTATES the roster.
Defaults to state=invited and notify=False: the person gets an invitation they must accept, and no email goes out until you ask for one. Pass enrollment_state="active" to place them straight onto the roster.
Args: user_id: numeric Canvas user id. "sis_user_id:ABC123" enrols by SIS id instead, which is usually what a registrar export gives you. enrollment_type: StudentEnrollment, TeacherEnrollment, TaEnrollment, ObserverEnrollment, or DesignerEnrollment. enrollment_state: invited (default) or active. notify: send Canvas's notification email (default False). section_id: enrol into a specific section instead of the default one. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: user_id (required), notify, course_id, section_id, +2 more. Returns: result
canvas_get_assignmentA
Get one assignment, with its description rendered to plain text.
Args: assignment_id: numeric assignment id. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID. max_chars: bound on the returned payload (0 = the server default).
Inputs: assignment_id (required), course_id, max_chars. Returns: result
canvas_get_courseA
Get one course: teachers, student count, and the syllabus as plain text.
Args: course_id: numeric id from the course URL; falls back to CANVAS_DEFAULT_COURSE_ID. max_chars: bound on the returned payload (0 = the server default).
Inputs: course_id, max_chars. Returns: result
canvas_get_discussionA
Get a discussion topic with its full reply thread as plain text.
FERPA: student posts are student work, attributed by name. Use this to summarise a week's discussion, not to bulk-export it.
Args: topic_id: numeric discussion topic id. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID. max_chars: bound on the returned payload (0 = the server default).
Inputs: topic_id (required), course_id, max_chars. Returns: result
canvas_get_gradebookA
Get the whole gradebook as one student-by-assignment table.
One call instead of N calls to canvas_list_submissions. Use it to find missing work, spot an assignment nobody passed, or summarise standing before office hours. FERPA: this is the full class record.
Args: course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID. assignment_ids: comma-separated ids to restrict to; empty for all. include_names: label rows with student names as well as ids. max_chars: bound on the returned payload (0 = the server default).
Inputs: course_id, max_chars, include_names, assignment_ids. Returns: result
canvas_get_pageA
Get one wiki page's body as plain text.
Args: page_url: the page's url slug (from canvas_list_pages). course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID. max_chars: bound on the returned payload (0 = the server default).
Inputs: page_url (required), course_id, max_chars. Returns: result
canvas_get_submissionA
Get one student's submission: body text, attachments, and comments.
FERPA: this returns a named student's submitted work. Treat accordingly — and note that attachment contents are not inlined, only listed; use canvas_download_submissions to fetch the files themselves.
Args: assignment_id: numeric assignment id. user_id: numeric Canvas user id, or "self". course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID. max_chars: bound on the returned payload (0 = the server default).
Inputs: user_id (required), assignment_id (required), course_id, max_chars. Returns: result
canvas_grade_submissionA
Post a grade and/or a comment to a submission. MUTATES STUDENT RECORDS.
Writes to the live gradebook immediately and cannot be undone from here. ALWAYS show the instructor the exact student, assignment, grade, and comment text and get an explicit go-ahead before calling. Never call this to "try" something or as part of exploratory reasoning.
Args: assignment_id: numeric assignment id. user_id: numeric Canvas user id of the student. grade: points ("18"), percentage ("88%"), or a letter grade. Omit to post a comment only. comment: comment posted alongside the grade; the student sees it. excused: True to excuse the student from the assignment entirely. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: user_id (required), assignment_id (required), grade, comment, +2 more. Returns: result
canvas_list_announcementsB
List a course's announcements, most recent first, with their text.
Args: course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID. max_chars: bound on the returned payload (0 = the server default).
Inputs: course_id, max_chars. Returns: result
canvas_list_assignment_groupsA
List assignment groups and their gradebook weights.
A course that grades by weighted categories ("Participation 20%, Papers 50%...") carries those weights here, not on the assignments. Read this before reasoning about what a score is worth.
Args: course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: course_id. Returns: result
canvas_list_assignmentsA
List assignments in a course, with due dates and needs-grading counts.
Args: course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID. bucket: optional filter — past, overdue, undated, ungraded, unsubmitted, upcoming, future. search_term: optional title substring filter.
Inputs: bucket, course_id, search_term. Returns: result
canvas_list_calendar_eventsA
List calendar events (and optionally assignment due dates) for a course.
Args: course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID. start_date: YYYY-MM-DD lower bound; empty for Canvas's default window. end_date: YYYY-MM-DD upper bound. include_assignments: also return assignment due dates as events.
Inputs: end_date, course_id, start_date, include_assignments. Returns: result
canvas_list_coursesA
List the courses the authenticated user can see.
Start here when you do not know the course id. The id in the output is what every other tool's course_id parameter wants.
Args: enrollment_state: active (default), completed, or invited_or_pending. enrollment_type: filter by your role — teacher, ta, student, observer, designer. Empty for all roles.
Inputs: enrollment_type, enrollment_state. Returns: result
canvas_list_discussionsB
List discussion topics in a course.
Args: course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: course_id. Returns: result
canvas_list_enrollmentsA
List enrollments, including the enrollment_id needed to change one.
canvas_list_students returns users; removing or modifying somebody needs the enrollment id, which is a different number. Fetch it here first — passing a user id to canvas_remove_enrollment silently targets the wrong record or 404s.
Args: course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID. role: StudentEnrollment, TeacherEnrollment, TaEnrollment, ObserverEnrollment, DesignerEnrollment. Empty for all. state: active, invited, concluded, completed, inactive. Empty for all.
Inputs: role, state, course_id. Returns: result
canvas_list_filesB
List files uploaded to a course.
Args: course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID. search_term: optional filename substring filter (3+ characters).
Inputs: course_id, search_term. Returns: result
canvas_list_modulesA
List course modules, optionally with their items — the course outline.
This is the fastest way to see how a course is actually structured week by week.
Args: course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID. with_items: inline each module's items (default True). max_chars: bound on the returned payload (0 = the server default).
Inputs: course_id, max_chars, with_items. Returns: result
canvas_list_pagesA
List wiki pages in a course (titles and url slugs, not bodies).
The url field is the slug every other page tool wants — not the
numeric page_id, and not the full browser URL.
Args: course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID. search_term: optional title substring filter.
Inputs: course_id, search_term. Returns: result
canvas_list_quizzesA
List quizzes in a course.
Note: this covers Classic Quizzes. Institutions on New Quizzes see them as assignments with submission_type=external_tool instead — check canvas_list_assignments if a quiz you expect is missing here.
Args: course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: course_id. Returns: result
canvas_list_sectionsA
List a course's sections with their enrollment counts.
Sections matter for anything scoped to part of a roster — section-level due dates, a lab subsection, or enrolling someone into one specific section rather than the course default.
Args: course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: course_id. Returns: result
canvas_list_studentsA
List the students enrolled in a course.
FERPA: returns student names, and email addresses when include_email=True. With CANVAS_REDACT_PII=1 identifiers come back as stable hashes instead.
Args: course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID. include_email: also request email addresses (default False). search_term: optional name/login substring filter (3+ characters).
Inputs: course_id, search_term, include_email. Returns: result
canvas_list_submissionsA
List submissions for an assignment: status, score, timestamps, lateness.
Metadata only — call canvas_get_submission for a student's actual work.
Args: assignment_id: numeric assignment id. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID. include_ungraded: keep submissions with no score yet (default True). only_submitted: drop students who have not turned anything in.
Inputs: assignment_id (required), course_id, only_submitted, include_ungraded. Returns: result
canvas_message_studentsA
Send a Canvas inbox message to one or more students. NOTIFIES PEOPLE.
This reaches students directly and cannot be recalled. Show the instructor the recipient list and the exact text, and get explicit approval, every time.
Defaults to individual conversations: each recipient gets their own thread and cannot see who else was written to. Only pass group_conversation=True when the students are meant to see each other — a group project thread, say — because otherwise it discloses the recipient list to everyone on it.
Args: recipient_ids: comma-separated Canvas user ids, or a JSON array. subject: message subject. body: message text. group_conversation: put all recipients in one shared thread. course_id: numeric course id; scopes the message to the course so students can reply. Defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: body (required), subject (required), recipient_ids (required), course_id, +1 more. Returns: result
canvas_post_announcementA
Post an announcement. MUTATES the course — students are notified.
Show the instructor the exact title and body and get explicit approval before calling. Canvas emails the whole roster on post, so deleting the announcement afterwards does not unsend it.
Pass delayed_post_at to schedule instead: the announcement is created but stays unpublished until that moment, which leaves a window to review or cancel it.
Args: title: announcement subject line. message: body (HTML allowed). delayed_post_at: ISO 8601 UTC; publish then instead of immediately. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: title (required), message (required), course_id, delayed_post_at. Returns: result
canvas_update_assignmentA
Edit an existing assignment. MUTATES the course.
Only the fields you pass are changed; omitted ones are left alone. Two edits have downstream gradebook effects worth flagging to the instructor: publishing an assignment students have not seen, and changing points_possible on one that is already graded (every existing score is silently re-scaled in the totals).
Args: assignment_id: numeric assignment id. name: new title, or empty to leave unchanged. description: new body HTML, or empty to leave unchanged. points_possible: new max score, or omit to leave unchanged. due_at: new ISO 8601 UTC due date, or empty to leave unchanged. unlock_at: new ISO 8601 UTC availability date. lock_at: new ISO 8601 UTC close date. published: True/False to change visibility, or omit to leave alone. assignment_group_id: move it to another gradebook category. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: assignment_id (required), name, due_at, lock_at, +6 more. Returns: result
canvas_update_courseA
Edit course settings. MUTATES the live course.
Only the fields you pass change. Publishing a course makes it visible to every enrolled student immediately, and Canvas will not let you unpublish once a student has submitted work — confirm before setting published=True.
Args: name: new course name, or empty to leave unchanged. course_code: new short code, or empty to leave unchanged. start_at: ISO 8601 UTC start, e.g. 2026-08-26T05:00:00Z. end_at: ISO 8601 UTC end. published: True to publish, False to unpublish, omit to leave alone. default_view: landing page — feed, wiki, modules, syllabus, assignments. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: name, end_at, start_at, course_id, +3 more. Returns: result
canvas_update_moduleA
Edit or publish a module. MUTATES the course.
Publishing a module publishes its items too, which is the usual way a week's content goes live for students. Only the fields you pass change.
Args: module_id: numeric module id. name: new title, or empty to leave unchanged. position: new 1-based slot, or omit to leave unchanged. published: True/False to change visibility, or omit to leave alone. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: module_id (required), name, position, course_id, +1 more. Returns: result
canvas_update_pageA
Edit a wiki page. MUTATES the course.
Only the fields you pass change. Passing body REPLACES the whole page — read canvas_get_page first if you mean to append. Note that canvas_get_page returns plain text, so round-tripping it through this tool will flatten the page's existing HTML formatting.
Args: page_url: the page's url slug (from canvas_list_pages), not its id. title: new title, or empty to leave unchanged. Renaming does NOT change the url slug, so existing links keep working. body: new page HTML, or empty to leave unchanged. published: True/False to change visibility, or omit to leave alone. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: page_url (required), body, title, course_id, +1 more. Returns: result
canvas_update_syllabusA
Replace the course syllabus body. MUTATES the live course page.
This OVERWRITES the existing syllabus wholesale — Canvas keeps no version history for it, so read canvas_get_course first if the current text matters, and show the instructor what is being replaced.
Args: body: the new syllabus HTML. Plain text works, but newlines are not converted to , so pass HTML if you want formatting. course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: body (required), course_id. Returns: result
canvas_upload_fileA
Upload a local file into the course's Files area. MUTATES the course.
Three-step Canvas dance, handled here: register the upload, POST the bytes to the storage host, then confirm. The Canvas token is never sent to the storage host.
Args: local_path: absolute path to the file on the machine running this server. parent_folder_path: Canvas folder, e.g. "course files/week03". Created if it does not exist. name: name to store it under; defaults to the local filename. on_duplicate: "rename" (default, keeps both) or "overwrite". course_id: numeric course id; defaults to CANVAS_DEFAULT_COURSE_ID.
Inputs: local_path (required), name, course_id, on_duplicate, +1 more. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 42 tools
Each tool targets a distinct resource and action, and descriptions actively head off confusion (e.g. canvas_list_students returns users while canvas_list_enrollments returns enrollment ids; canvas_list_submissions is metadata-only while canvas_get_submission returns the work). A few pairs sit close together (download_submissions vs download_file, get_gradebook vs list_submissions, api_get as a catch-all), but none is genuinely ambiguous.
Nearly all tools follow a canvas_<verb>_<noun> pattern (get_assignment, list_courses, create_page, update_module, download_file, grade_submission). Minor deviations exist — canvas_auth_status is noun-noun and canvas_api_get inverts the pattern — but the convention is largely predictable.
42 tools is heavy and pushes past the comfortable range, but the Canvas teaching domain is genuinely broad (gradebook, submissions, pages, modules, files, discussions, calendar, messaging). Each tool maps to a distinct operation and an api_get escape hatch absorbs the long tail, so the count is defensible though on the borderline of unwieldy.
Create/read/update coverage is strong across assignments, pages, modules, discussions, and grading, but deletions are almost entirely absent (no delete page/module/assignment/file/discussion). Notably, canvas_list_enrollments references a canvas_remove_enrollment tool that is not published, leaving a dangling handle that would trap an agent trying to drop a student.
Maintenance
Related MCP Connectors
Create, edit, translate, and export SCORM eLearning modules from a connected AI assistant.
Manage your Canvas coursework with quick access to courses, assignments, and grades. Track upcomin…
Study from your own classes: synced Canvas coursework, notes, flashcards and study progress.
Generate AI images, video, voiceovers and music from Claude, ChatGPT or Cursor through 50+ models (Veo 3.1, Kling 3, Seedance, Nano Banana, GPT Image, ElevenLabs). Also image editing, upscaling, background removal, face swap, transcription, voice cloning and UGC-style video ads. Sign in with OAuth — no API key to paste. Tools are annotated (read-only vs. credit-spending); failed generations are refunded.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables AI assistants to interact with Canvas LMS through 25 comprehensive tools. Supports course management, assignments, grades, messaging, calendar events, and file access through natural language.14-
- AlicenseBqualityCmaintenanceEnables AI assistants to manage Canvas LMS courses, announcements, rubrics, assignments, modules, pages, and student data via the Canvas API.6043 npm12MIT
- FlicenseBqualityBmaintenanceEnables AI assistants to act as teaching assistants for Canvas LMS, allowing them to browse courses, read student submissions (including PDF/DOCX), grade with rubrics, post announcements, manage modules and pages, and more.64-
- FlicenseNot gradedqualityBmaintenanceEnables AI assistants to interact with a student's Canvas LMS account, supporting course viewing, grade checks, assignment submissions, announcements, discussions, calendar events, inbox messages, and more via specialized tools.1-