canvas-parent-mcp
A read-only MCP server that exposes Canvas LMS data to a parent observer or student through 18 canvas_* tools.
Verify credentials and Canvas reachability, and see which auth source was used (
canvas_healthcheck).View your own Canvas profile (name, email, login id, locale, time zone).
List students linked to your observer account (observees/children).
List active courses with grades, scores, term, and get a single course's syllabus and teachers.
List assignments (with your/child's submission inline) and list missing past-due submissions.
Get a single submission (rubric and comments) and list recently graded submissions (default 14-day window).
List enrollments with per-course current/final grades and grading period info.
List calendar events, upcoming events, and planner items (assignments, announcements, notes, events) for yourself or a linked child, with a one-line
briefview option.Read announcements and discussion topics across courses; teacher-written HTML is converted to Markdown by default.
List and read Canvas inbox conversations (read-only).
List course files and download a file to disk (local) or get a signed expiring link / inline image (hosted).
Authenticate via personal access token, OAuth refresh token, username/password, or a browser-extension cookie fallback.
Provides tools to interact with the Canvas LMS API for parent observers and student self-access, including profile, courses, assignments, submissions, grades, calendar, planner, announcements, conversations, discussions, and files.
Integrates with Instructure's Canvas LMS platform to provide read-only access to educational data for parent observers and students via the Canvas 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-parent-mcp Show my child's upcoming assignments"
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-parent-mcp
MCP server for Canvas LMS (Instructure), scoped for parent observers and student self-access. Targets https://cms.instructure.com by default but works against any Canvas instance.
Mirrors the read-only parent-portal scope of sibling infinitecampus-mcp. Users interact via the canvas_* tool prefix.
Tools
18 tools across profile, observees, courses, assignments, submissions, grades, calendar, planner, announcements, conversations, discussions, and files.
Domain | Tools |
Profile |
|
Observees |
|
Courses |
|
Assignments |
|
Submissions |
|
Grades |
|
Calendar |
|
Planner |
|
Announcements |
|
Conversations |
|
Discussions |
|
Files |
|
Tools that the harness will gate as write/IO operations: canvas_download_file.
Planner: child names and a brief view
canvas_list_planner_items takes a child by name. At start the server lists your observees once (bounded to 5 s) and publishes their display names as the observeeId enum; the tool accepts either a name (any case) or a Canvas user id (self, a numeric id, or a sis_user_id:-style reference — including a child linked after the server started), and an unknown name is refused with the list of known ones. If the listing fails or you observe nobody, observeeId is published as a plain string and ids pass through as before. Two children with the same display name are listed as Name (id).
view: "brief" returns one line per planner item, at most 120 characters (cut as a whole, title first): title — <ISO date or "no date"> — <submitted|not submitted|missing>. Items with nothing to submit (planner notes, pages, events) carry their kind as the status (planner note, wiki page, …). Titles are written by teachers, so the lines come back inside the untrusted-data envelope, {"untrusted_content":true,"note":"…","data":["…"]}; an empty planner is data: ["-- none"], and a title that itself starts with -- or \ is escaped with one leading \ so it never reads as a note. The default (view: "full") is Canvas's payload, unchanged.
Teacher-written text as Markdown
Canvas stores announcements, discussion posts, assignment and calendar descriptions, syllabi and online-text submissions as HTML. The reads that return them (canvas_list_announcements, canvas_list_discussion_topics, canvas_get_course, canvas_get_submission, canvas_list_recent_submissions, canvas_list_assignments, canvas_list_missing_submissions, canvas_list_calendar_events, canvas_list_upcoming_events) return that text as Markdown by default (view: "compact"): lists, tables, emphasis and links kept; styling, text hidden from the page, and Canvas's "Links to an external site." dropped; images as [alt text]; an embedded video as a link to it. On one observer account this cut announcement responses by about a quarter. view: "full" returns Canvas's HTML unchanged. Inbox conversations are plain text and are not converted.
Context-group hints
Every tool except canvas_healthcheck carries a _meta.mint hint for hosts that group tools by context (mcp-host's context groups): domain: "school" plus an intent — whats-due for the planner and missing submissions, whats-new for announcements, whats-on for the calendar tools, lookup for the other reads, other for the download. The planner (whats-due) and announcements (whats-new) are marked canonical; the planner also names its subject argument (observeeId) and range (startDate/endDate). Hosts that do not read _meta see nothing different.
canvas_download_file only fetches /files/… URLs on your CANVAS_BASE_URL host (https), so your Canvas credential is never sent anywhere else, and it only writes inside a download directory: CANVAS_OUTPUT_DIR if set, otherwise ~/Downloads. A relative destinationPath is resolved against that directory. It never writes through a symlink at the destination, and new files are created owner-only (0600).
On a hosted deployment (mcp-host) the server's disk is not reachable from your session, so canvas_download_file writes nothing to disk: it reads the file (up to 100 MiB) and returns a signed download link that expires after an hour. An image under 10 MiB is shown inline instead. destinationPath is ignored there. A hosted server without a blob store returns files up to 10 MiB inline and refuses larger ones. On a local install, destinationPath is now optional; leave it out and the file is saved under its own name in the download directory, never overwriting an existing file.
Related MCP server: canvas-lms
Configuration
Set CANVAS_BASE_URL plus one of four auth modes. canvas-parent-mcp tries them in priority order:
CANVAS_TOKEN→ personal access tokenCANVAS_CLIENT_ID+CANVAS_CLIENT_SECRET+CANVAS_REFRESH_TOKEN→ OAuthCANVAS_USERNAME+CANVAS_PASSWORD→ session-scrape (direct Canvas accounts only)fetchproxy fallback → no env vars needed; reads
canvas_session+pseudonym_credentialscookies from your signed-in Canvas tab via the ContextMint Bridge browser extension
If none succeed, you get an error that names every escape hatch.
Mode A — fetchproxy fallback (recommended, zero config)
CANVAS_BASE_URL=https://cms.instructure.comInstall the ContextMint Bridge browser extension from its releases page (Chrome: download the chrome zip, unzip it, and load it unpacked at chrome://extensions with Developer mode on — there is no Chrome Web Store listing yet; Safari: not available yet — it will ship inside the ContextMint app, which has no public download yet, so use Chrome for now), sign into your Canvas instance, and the MCP reads your session cookies from the browser on the first request and again whenever Canvas answers 401 (the session expired). In between, Canvas API calls go directly from Node — the extension is not in the request hot path, but it must stay reachable (browser running, extension installed) for the MCP to renew the session. Works with any auth flow (SSO/SAML/2FA included) because Canvas itself handled the sign-in.
Where the extension comes from. ContextMint Bridge is the fetchproxy browser extension under its new name, from the same maintainer — fetchproxy's own README (Extension) points to it. Its source is public at nullnet-app/contextmint-bridge: build it yourself (
npm run build, per its README), or check a release zip against the.sha256file published beside it:shasum -a 256 -c contextmint-bridge-chrome-<version>.zip.sha256
Multiple districts? Declared domain instructure.com matches every *.instructure.com host, so you only pair the extension once. The MCP uses whichever district you set in CANVAS_BASE_URL.
Set CANVAS_DISABLE_FETCHPROXY=1 to opt out (missing creds become a hard error — useful in headless CI).
Mode B — username/password (legacy session-scrape)
CANVAS_BASE_URL=https://cms.instructure.com
CANVAS_USERNAME=me@example.com
CANVAS_PASSWORD=your-canvas-password
CANVAS_NAME=cms # optional, defaults to host portion of base URLDirect Canvas accounts only — won't work with SAML/Google/Microsoft SSO or 2FA. Brittle (breaks on every Canvas login-page restyling). Prefer fetchproxy if your tab is already signed in. Treat .env like a password file.
Advanced alternatives
CANVAS_BASE_URL=https://cms.instructure.com
CANVAS_TOKEN=your-personal-access-tokenGenerate via Canvas → Account → Settings → "+ New Access Token". Most institutions have disabled this for non-admins.
CANVAS_BASE_URL=https://cms.instructure.com
CANVAS_CLIENT_ID=...
CANVAS_CLIENT_SECRET=...
CANVAS_REFRESH_TOKEN=...If your account uses SSO and you can't use fetchproxy (e.g. headless server), mint OAuth credentials by reusing the Canvas mobile-app QR-login flow — see Bootstrapping OAuth via the mobile QR code below.
Precedence when multiple are set: CANVAS_TOKEN > username/password > OAuth > fetchproxy.
See .env.example.
Session cache
In username/password and OAuth modes the signed-in session is cached between runs, so a restart does not log in (or spend a refresh-token exchange) again. The cache file — $MCP_DATA_DIR/.canvas-parent-mcp/session.json by default, or CANVAS_SESSION_FILE — holds the live canvas_session + pseudonym_credentials cookies or the OAuth access token in plaintext. It is created owner-only (0600, in a 0700 directory), and only the credential binding is stored as a salted digest; your username, password and refresh token are never written to it. Token and fetchproxy modes never write the cache.
Backup and sync tools that run as you can still copy that file. On a shared or backed-up machine, set CANVAS_SESSION_CACHE=false to keep the session in memory only (each start then re-authenticates).
Bootstrapping OAuth via the mobile QR code
If your Canvas admin has disabled personal-access-token creation (some institutions restrict tokens to "the mobile app only") AND your account uses SSO so username/password can't auth, you can mint OAuth credentials by going through the same QR-login flow that the official Canvas mobile apps use:
In Canvas web, open Account → QR for Mobile Login — Canvas shows a QR that's valid for 10 minutes.
Decode the QR with any QR reader. The result is a URL on
sso.canvaslms.comlikehttps://sso.canvaslms.com/canvas/login?domain=...&code=....Run the bundled helper:
npx canvas-parent-mcp-qr-login "<decoded-qr-url>" >> .envIt hits Canvas's public
mobile_verify.jsonendpoint to fetch the mobile client_id/client_secret, exchanges the QR's one-time code for an access+refresh token pair, and printsCANVAS_BASE_URL/CANVAS_CLIENT_ID/CANVAS_CLIENT_SECRET/CANVAS_REFRESH_TOKENto stdout. The refresh token is sensitive — treat it like a password.
This reuses the same SSO + OAuth endpoints the official Canvas Student/Parent apps use; from Canvas's perspective the resulting session looks like a mobile-app session. Use it only against accounts you legitimately control.
Upgrading
next release
canvas_download_file now works on hosted deployments:
destinationPathis optional (it was required). Local calls that pass it behave exactly as before and return the same{path, bytes, contentType}.Calls without
destinationPath, and every call on a hosted server, return a delivery result instead:{via, fileName, mimeType, url?, expiresAt?, path?, bytes, contentType, note?}.viaisimage(inline image block),resource(inline bytes),link(signedurlvalid untilexpiresAt) ordisk(path). An inline image or resource is returned as a content block before that JSON.On a hosted server
destinationPathis ignored and thenotesays so.
Status
Unofficial — not affiliated with Instructure. AI-maintained.
Acknowledgement of Terms
By using this MCP server, you acknowledge and agree to the following:
1. This server accesses your own Canvas account via the official Canvas REST API. Auth happens via your own personal access token, issued by your institution. It does not — and cannot — access anyone else's enrollments, grades, or messages.
2. Instructure's Canvas API Policy governs your use of this server, in addition to your institution's own acceptable-use policy. The clauses most relevant here:
You may not use our APIs on behalf of any third-party… You may not use or access our APIs for competitive purposes… You may not interfere with our APIs, our systems, or other users… You may not circumvent any contractual usage limits.
On rate limits: "limits are enforced per user access token… with dynamic throttling." On data: "Any user information retrieved through the API—including course enrollments, grades, and profile information—should be considered and treated as private information."
You are agreeing to those terms — read by the maintainer 2026-05-23 — every time you invoke a tool in this server.
3. Personal, observer/student/parent use only. This project is not affiliated with, endorsed by, sponsored by, or in partnership with Instructure, Inc. or any school district. It is a personal automation tool for an authenticated Canvas user (typically a parent observer) to read their own (or their student's) enrollments, assignments, grades, and announcements. Do not use it to bulk-extract a district's course content, redistribute student data, or train AI models on student records.
4. FERPA + your institution's AUP apply. Student educational records are protected under the federal Family Educational Rights and Privacy Act (FERPA). Even though your token grants you lawful access, how you store, redistribute, or feed that data into LLMs is regulated. Treat any output (grades, assignments, comments, conversations) as confidential student data. Your institution's acceptable-use policy may add further restrictions on automated access — check before automating.
5. Your token is yours alone. Do not commit CANVAS_API_TOKEN to git, do not paste it in shared chats, and rotate it if it's ever exposed. A leaked token grants full Canvas access scoped to your user.
6. You accept full responsibility for any consequences of using this server in connection with your Canvas account — rate limiting (dynamic throttling kicks in well below documented limits when Canvas is under load), token revocation, account warnings, institution-admin investigations, or any enforcement action. If Instructure or your institution objects to your use, stop using this server.
This section is the maintainer's good-faith summary of the terms — it is not legal advice and does not modify or supersede Instructure's actual Canvas API Policy or your institution's policies.
Available Tools
19 toolscanvas_download_fileADestructive
Download a Canvas file. url is the absolute URL from canvas_list_course_files (only file URLs on the configured Canvas host are accepted). On a local install the file is written to disk inside the download directory (CANVAS_OUTPUT_DIR, default ~/Downloads) — at destinationPath if given, else under its own name. On a hosted server it comes back as a signed, expiring download link (an image small enough is shown inline); give the link to the user.
Inputs: url (required), overwrite, destinationPath.
canvas_get_conversationARead-only
Get a full Canvas conversation thread with all messages. Read-only: does not mark the conversation as read.
Inputs: id (required), view.
canvas_get_courseARead-only
Get a single Canvas course with its syllabus, teachers, and term.
Inputs: courseId (required), view.
canvas_get_profileARead-only
Get the logged-in user's Canvas profile (id, name, primary_email, login_id, locale, time_zone). Useful first call to confirm credentials.
Inputs: view.
canvas_get_submissionBRead-only
Get a single submission with rubric assessment and grader comments. userId defaults to 'self'.
Inputs: courseId (required), assignmentId (required), view, userId.
canvas_healthcheckVerify credentials and upstream reachabilityARead-onlyIdempotent
Resolves the credential the way real tools do, then makes one authenticated request to canvas. Reports which source supplied the credential, whether canvas accepted it, the round-trip time, and a plain-English hint distinguishing 'no credential' from 'credential rejected' from 'a canvas-side problem'. Read-only; never returns the credential itself. Call this when a real tool fails and you want to know which hop broke.
Inputs: no named parameters.
canvas_list_announcementsBRead-only
List announcements across one or more courses. contextCodes is required (e.g. ["course_123"]). Defaults to active-only.
Inputs: contextCodes (required), view, endDate, startDate, +1 more.
canvas_list_assignmentsBRead-only
List a course's assignments — homework, quizzes and projects — with the user's (or child's) submission inline. Supports the standard Canvas bucket filter.
Inputs: courseId (required), view, bucket.
canvas_list_calendar_eventsCRead-only
List Canvas calendar events or assignments across selected contexts (courses/users).
Inputs: type, view, endDate, allEvents, +2 more.
canvas_list_conversationsCRead-only
List Canvas inbox conversations. Optional scope (unread/starred/archived/sent) and filter (array of context codes).
Inputs: view, scope, filter.
canvas_list_course_filesARead-only
List a course's files (metadata only — use canvas_download_file with the url field).
Inputs: courseId (required), searchTerm, contentTypes.
canvas_list_coursesBRead-only
List active Canvas courses (with course-level grades, total scores, current grading period scores, and term).
Inputs: observeeId.
canvas_list_discussion_topicsCRead-only
List discussion topics for a course (read-only).
Inputs: courseId (required), view, orderBy, onlyAnnouncements.
canvas_list_enrollmentsBRead-only
List active student enrollments with per-course grades (current_score, final_score, current_grade, final_grade, current grading period info).
Inputs: observeeId.
canvas_list_missing_submissionsARead-only
List missing homework: past-due unsubmitted assignments for the user (or a linked observee, e.g. a child). For an observee, courseIds is required.
Inputs: view, courseIds, observeeId.
canvas_list_observeesARead-only
List students linked to your Canvas observer account. Returns an empty array for plain student tokens.
Inputs: view.
canvas_list_planner_itemsARead-only
List planner items (assignments + announcements + planner notes + calendar events) for the user or a linked observee.
Inputs: view, filter, endDate, startDate, +2 more.
canvas_list_recent_submissionsARead-only
List recently graded submissions in a course. Defaults to a 14-day window for the calling user.
Inputs: courseId (required), view, since, studentId.
canvas_list_upcoming_eventsARead-only
List the calling user's upcoming events (Canvas's curated next-7-days view).
Inputs: view.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 19 tools
Most tools target a distinct resource+action, and descriptions actively disambiguate the tricky pairs (list_calendar_events vs list_upcoming_events vs list_planner_items; list_missing_submissions vs list_recent_submissions vs list_assignments). Some residual overlap remains in the calendar/planner/events cluster and the submission-listing cluster, where an agent must read descriptions carefully to choose correctly.
Every tool uses the same canvas_ prefix followed by a verb_noun pattern (get_course, list_assignments, download_file, get_conversation), all in snake_case. Verb choice is predictable: list_ for collections, get_ for single items, download_ for binary fetch, healthcheck as the one deliberate exception.
19 tools is on the heavier side, but the Canvas domain is broad (courses, assignments, submissions, calendar, planner, announcements, discussions, files, inbox, enrollments, observees) and each tool maps to a distinct read surface. A few could arguably be consolidated (the three event/planner listing tools), keeping it just shy of ideal.
Coverage is thorough on the read side, so agents can survey nearly every Canvas object, but the surface is essentially read-only: there is no assignment submission, no discussion post/reply, no conversation send or mark-read, and no planner note creation. An agent asked to actually do something in Canvas hits a dead end after the listing tools.
Maintenance
Related MCP Connectors
Read-only MCP server for ClassQuill, a tutoring-business-management platform.
Remote MCP server for training, nutrition, wellness, and performance data with OAuth 2.0.
MCP adapter for the Paxaver school community platform. Streamable HTTP, OAuth 2.1, capability auth.
MCP server for Nylas — read email, calendars, events and contacts, and send email or create events.
Related MCP Servers
- AlicenseBqualityDmaintenanceA local MCP server for Canvas LMS that enables querying courses, assignments, grades, modules, and more from any MCP-compatible AI client.12MIT
- AlicenseNot gradedqualityCmaintenanceMCP server for Canvas LMS with automatic OAuth authentication. Enables interaction with courses, assignments, grades, modules, discussions, quizzes, files, calendar, messaging, and more without manual API token management.2MIT
- AlicenseBqualityDmaintenanceA read-only MCP server for Canvas LMS that exposes a user's courses, upcoming work, and assignments as callable tools.3MIT
- AlicenseAqualityCmaintenanceRead-only MCP server for Canvas LMS that exposes tools to list courses, assignments, grades, submissions, syllabi, announcements, modules, pages, and files, without any write operations.1112 npm1MIT