Skip to main content
Glama

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 list_submissions doesn't eat your context window

Readable text, not raw HTML

syllabi, pages, and discussion threads come back as plain text with paragraph breaks intact

Optional PII redaction

CANVAS_REDACT_PII=1 replaces emails and SIS ids with stable anon-… hashes

Retries that understand Canvas

Canvas signals rate limiting with a 403, not a 429; this server tells the two apart and only retries the right one

A doctor command

tells you exactly which of base-url / token / permissions / course-id is wrong, instead of a generic 401

No vendor lock-in

pure requests against the public Canvas REST API; no Canvas app registration, no OAuth dance, no admin approval


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 doctor

With pip:

pip install git+https://github.com/zhenghh04/canvas-mcp

From 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 course

Requires 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.

  1. Log in to Canvas in a browser.

  2. Click Account (left sidebar) → Settings.

  3. Scroll to Approved Integrations.

  4. Click + New Access Token.

  5. 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.

  6. Click Generate Token.

  7. 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 id

Setting 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 env block)

2

$CANVAS_MCP_ENV_FILE — point this at any file you like

3

./.env in the current directory

4

~/.config/canvas-mcp/.env

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/.env

That chmod matters — the file now contains a credential.

See env.example for every available setting, annotated.

5. Check it works

canvas-mcp doctor

A 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 serve

Or 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.json

  • Windows — %APPDATA%\Claude\claude_desktop_config.json

  • Linux — ~/.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 default

Or serve over HTTP for a remote or multi-client setup:

canvas-mcp serve --transport http --host 127.0.0.1 --port 8900

Bind 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

CANVAS_ENABLE_WRITES=0 to disable

18 tools. Create and edit assignments, pages, modules; post grades; send announcements and messages.

destructive

off

CANVAS_ALLOW_DESTRUCTIVE=1 to enable

5 tools. Delete assignments, pages, modules; remove enrollments; arbitrary POST/PUT/DELETE.

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=1

Beyond 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, and canvas_create_module all 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_submissions writes attachments to disk, and ../../.ssh/authorized_keys is a perfectly legal Canvas filename.

  • Messages don't leak the recipient list. canvas_message_students sends 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

canvas_auth_status

Check connectivity, identity, and which tiers are enabled. Call this first.

canvas_api_get

Escape hatch: GET any Canvas REST endpoint that has no dedicated tool.

!!

canvas_api_write

Escape hatch: POST/PUT/DELETE any endpoint. Unrestricted.

Courses

Tool

What it does

canvas_list_courses

List the courses you can see.

canvas_get_course

One course: teachers, student count, syllabus as plain text.

canvas_list_sections

Sections with enrollment counts.

!

canvas_update_course

Edit course settings (name, dates, publish state).

!

canvas_update_syllabus

Replace the syllabus body.

People

Tool

What it does

canvas_list_students

The roster.

canvas_list_enrollments

Enrollments including the enrollment_id you need to change one.

!

canvas_enroll_user

Add a user to the course.

!!

canvas_remove_enrollment

Remove someone from the course.

Assignments

Tool

What it does

canvas_list_assignments

Assignments with due dates and needs-grading counts.

canvas_get_assignment

One assignment, description rendered to plain text.

canvas_list_assignment_groups

Gradebook categories and their weights.

!

canvas_create_assignment_group

Create a gradebook category.

!

canvas_create_assignment

Create an assignment (unpublished by default).

!

canvas_update_assignment

Edit an existing assignment.

!!

canvas_delete_assignment

Delete an assignment.

Grading

Tool

What it does

canvas_list_submissions

Status, score, timestamps, lateness for an assignment.

canvas_get_submission

One student's submission: body text, attachments, comments.

canvas_get_gradebook

The whole gradebook as one student × assignment table.

canvas_download_submissions

Download every file attachment for an assignment.

!

canvas_grade_submission

Post a grade and/or a comment.

!

canvas_bulk_grade

Post many grades to one assignment at once.

Content

Tool

What it does

canvas_list_pages

Wiki page titles and url slugs.

canvas_get_page

One page's body as plain text.

canvas_list_modules

The course outline, optionally with items.

canvas_list_quizzes

Quizzes in a course.

canvas_list_files

Files uploaded to a course.

canvas_download_file

Download one course file.

!

canvas_create_page

Create a wiki page (unpublished by default).

!

canvas_update_page

Edit a wiki page.

!

canvas_create_module

Create a module (unpublished by default).

!

canvas_update_module

Edit or publish a module.

!

canvas_create_module_item

Add a page / assignment / quiz / link to a module.

!

canvas_upload_file

Upload a local file into Files.

!!

canvas_delete_page

Delete a wiki page.

!!

canvas_delete_module

Delete a module.

Communication

Tool

What it does

canvas_list_announcements

Announcements, newest first, with their text.

canvas_list_discussions

Discussion topics.

canvas_get_discussion

A topic with its full reply thread as plain text.

canvas_list_calendar_events

Calendar events, optionally with assignment due dates.

!

canvas_post_announcement

Post an announcement — students are notified.

!

canvas_create_discussion

Create a discussion topic.

!

canvas_create_calendar_event

Add an event to the course calendar.

!

canvas_message_students

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

CANVAS_BASE_URL

https://yourschool.instructure.com

No trailing slash needed; one is stripped. Do not include /api/v1.

CANVAS_API_TOKEN

7~abc123…

From Account → Settings → New Access Token.

Convenience

Variable

Default

Notes

CANVAS_DEFAULT_COURSE_ID

—

Used whenever a tool's course_id is omitted.

CANVAS_MCP_ENV_FILE

—

Path to a .env file to load first.

CANVAS_DOWNLOAD_DIR

./canvas-downloads

Where downloaded files and submissions land.

Safety

Variable

Default

Notes

CANVAS_ENABLE_WRITES

1

0 for a strictly read-only server.

CANVAS_ALLOW_DESTRUCTIVE

0

1 publishes the five delete/raw-write tools.

CANVAS_REDACT_PII

0

1 pseudonymises emails, login ids, SIS ids.

Trimming the tool surface

Fewer tools means less context spent and fewer ways to go wrong.

Variable

Example

Notes

CANVAS_TOOL_GROUPS

courses,assignments,grading

Comma-separated. Groups: diagnostics, courses, people, assignments, grading, content, communication.

CANVAS_TOOLS

canvas_auth_status,canvas_get_gradebook

Strict allowlist. Only these, and only if their tier is enabled.

CANVAS_DISABLE_TOOLS

canvas_message_students

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

CANVAS_TIMEOUT

30

Seconds per API request.

CANVAS_UPLOAD_TIMEOUT

300

Seconds for file uploads.

CANVAS_MAX_UPLOAD_MB

100

Refuse larger local files.

CANVAS_PER_PAGE

100

Canvas page size.

CANVAS_MAX_PAGES

10

Pagination cap. Results past it are marked _truncated.

CANVAS_MAX_CHARS

20000

Response size cap, with an explicit truncation notice.

CANVAS_MAX_RETRIES

3

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:

  1. canvas-mcp config — which env file did it load? If env file: (none), it found no file at any of the four locations.

  2. Your MCP client may start the server in a different working directory, so a ./.env won't be found. Use ~/.config/canvas-mcp/.env.

  3. Make sure the file has no quotes and no spaces around =: CANVAS_API_TOKEN=7~abc — not CANVAS_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_TIMEOUT and 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_students or 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.

  1. Restart the client fully (Claude Desktop needs a real quit, not a window reload).

  2. Run the exact command from your config by hand in a terminal. If canvas-mcp: command not found, your client doesn't share your shell PATH — use an absolute path from which canvas-mcp, or switch to the uvx form.

  3. 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 tools
canvas_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

    A3.7/5.0

    Scored across 42 tools

    Disambiguation4/5

    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.

    Naming Consistency4/5

    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.

    Tool Count3/5

    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.

    Completeness3/5

    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

    ActivitySlowing
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers