Canvas Lms MCP

Create a new discussion topic in a course, and return the created topic (id, title, message, discussion_type, published, is_announcement, posted_at). Not idempotent: each call creates another topic — Canvas does not deduplicate by title, so check list_discussions first to avoid creating a duplicate. Setting is_announcement: true asks Canvas to create an announcement, but Canvas silently creates a plain discussion topic instead (HTTP 200, no error) if the caller lacks announcement-create permission in the course — this tool then throws instead of reporting success, naming the topic ID so you ca…

Create a new grading standard (letter-to-percentage scheme) in a course or account context. Provide either course_id or account_id (account requires admin). scheme_entries is an array of { name, value } objects where value is the lower-bound percentage as a fraction 0–1 (e.g. { name: "A", value: 0.94 } means A ≥ 94%). Entries will be sorted descending by value before sending to Canvas. Canvas POST body key is grading_scheme_entry (singular); the returned object uses grading_scheme (plural). Returns the created grading standard object including its id — use that id with apply_grading_standard_t…

Create a group inside a group category. This is addressed by group_category_id, not by course ID: find the category with list_group_categories. The new group has no members; add them with add_group_member.

Create a new, empty group category (group set) in a course.

Create a new module in a course. Returns the created module, including its new Canvas ID. Each call creates a separate module — calling it twice with the same name makes two modules, not one — so check `list_modules` first if you want to avoid duplicates. New modules are always created unpublished, regardless of any other field; use `update_module` with `published: true` to make one visible to students. `prerequisite_module_ids` silently drops any ID that is not an existing module positioned before this one in the course — Canvas does not error on an invalid ID, it just ignores it. Once create…

Add an item to a module: Assignment, Page, Quiz, File, Discussion, ExternalUrl, ExternalTool or SubHeader. Returns the created module item, including its new Canvas ID. Each call adds a new item — calling it twice with the same title adds two items, not one. Which identifying field to pass depends on `type`: `page_url` for Page (addressed by slug, not ID), `content_id` for File, Discussion, Assignment or Quiz, `external_url` for ExternalUrl or ExternalTool, and neither for SubHeader. Use `list_module_items` to see what is already in the module, and `update_module_item` or `delete_module_item` …

Create a New Quiz (LTI) in a Canvas course. Returns the created quiz with its id, assignment_id, and current field values. New Quizzes is Canvas's current quiz engine; there is no tool here to create a Classic quiz — list_quizzes, get_quiz, and delete_quiz only read and delete that older type. After creating, add questions with create_new_quiz_item, change title, dates, or points with update_new_quiz, and remove the quiz with delete_new_quiz. Each call creates another quiz (not idempotent), so check list_quizzes before retrying. Requires permission to manage quizzes in the course.

Create an item (question) in a New Quiz (LTI). Supports 5 types: choice (MCQ), true-false, essay, matching, numeric. Canvas may rate-limit rapid sequential creates. Call serially (not in parallel). For >50 items, chunk and pause between batches.

Create a new wiki page in a course with a title and optional HTML body, published state and editing_roles, and return the created page — including its url slug, used as page_url by get_page, update_page and delete_page. Not idempotent: each call creates another page; Canvas does not deduplicate by title, so check list_pages first to avoid creating a duplicate. Use update_page to edit an existing page instead of creating a new one, and create_module_item's page_url parameter (with type Page) to place this page inside a module. Requires permission to manage wiki content in the course.

Assign a Canvas user as a peer reviewer for one submission, and return the created peer review object (id, assessor_id, user_id, asset_id, workflow_state). The user_id parameter you pass is the reviewer being assigned; in the returned object assessor_id holds that same reviewer, while the response's own user_id field instead identifies the submission owner (the reviewee) — the two user_id values are not the same person. The new review starts in workflow_state "assigned". submission_id must already exist on this assignment. Use list_peer_reviews to see every review assigned on the whole assignm…

Create a new rubric in a course with criteria and rating levels. Optionally link it to an assignment immediately. Returns { rubric, rubric_association? }; when an assignment association was requested, rubric_association.id is the association_id that submit_rubric_assessment takes.

Delete an appointment group by id, canceling every time slot and reservation on it and emailing every signed-up participant, then return the deleted group object. This is permanent: the group and its slots cannot be recovered afterward. Pass cancel_reason to include why in that cancellation email. Find the id with list_appointment_groups, and check list_appointment_group_users or list_appointment_group_groups first if you need to know who will be notified. Requires permission to manage the Scheduler in the group's context.

Permanently delete an assignment from a course; this cannot be undone. Returns no assignment object, only an acknowledgement that the deletion succeeded. Use update_assignment instead to change the assignment rather than remove it, or create_assignment afterward to make a new one — Canvas assigns it a new ID rather than reusing the deleted one. Requires instructor/TA permission to manage assignments and quizzes in the course.

Delete a discussion topic from a course. This action is permanent.

Permanently delete a file by ID, and return the deleted file object (its last known metadata) — the content is gone and there is no undelete. Use upload_file to put a replacement back afterward; Canvas assigns the new file a different ID rather than reusing the deleted one. Requires permission to manage files in the course.

Permanently delete a group and remove all of its members. The students stay enrolled in the course and the group category remains. Creating a group again does not restore the same group.

Permanently delete a module from a course, including its ordered list of module items. Assignments, pages, quizzes, files and discussions that the items link to are stored separately in the course and this call does not delete them, but ExternalUrl, ExternalTool and SubHeader items exist only inside the module and go with it. There is no single inverse: rebuilding the module means create_module plus create_module_item for each item.

Remove an item from a module. For ExternalUrl, ExternalTool and SubHeader items the item is the content, so this deletes it outright; for Assignment, Page, Quiz, File and Discussion items it only unlinks the item and the underlying content survives. Re-add with create_module_item.

Delete a New Quiz (LTI) from a Canvas course. This action is permanent. Use assignment_id (not quiz_id).

Permanently delete one item (question or stimulus) from a New Quiz (LTI) by its item_id. This is irreversible — there is no undo and no tool to restore a deleted item. Returns { success: true }; Canvas does not hand back the deleted item. Find item_id with list_new_quiz_items or get_new_quiz_item. Use delete_new_quiz instead to remove the whole quiz, or update_new_quiz_item if you only need to change the item rather than remove it. assignment_id identifies the New Quiz (from list_assignments or get_assignment, filtered on is_quiz_lti_assignment), not a Classic Quiz ID. Requires permission to m…

Delete a wiki page from a course. This action is permanent.

Remove a peer-review assignment — identified by its assessor_id/user_id pairing — from one submission, unassigning that reviewer; the submission and the assignment itself are untouched, only the peer-review relationship goes away. Returns a confirmation message; Canvas's own response body is discarded. This is a reversible relationship removal, not an irreversible content delete: re-create the assignment with create_peer_review, though the new review gets a new id and workflow_state starts over at "assigned". Find the reviewer's user_id to remove with list_peer_reviews or get_submission_peer_r…

Permanently delete a Classic quiz from a course, including its questions and every student submission. Classic Quizzes only; use delete_new_quiz for a New Quiz (LTI).

Permanently delete a single question from a Classic quiz. Classic Quizzes only; use delete_new_quiz_item for a New Quiz item.

Permanently delete a rubric from a course, removing it from every assignment it is attached to. Returns the deleted rubric.

Download the content of a Canvas file by ID. Text files (plain text, HTML, JSON, XML, JavaScript) are returned as readable text. Binary files (images, PDFs, etc.) are returned as base64-encoded data. Files larger than 10 MB are refused.

Enroll a user in a course with a given role (StudentEnrollment, TeacherEnrollment, TaEnrollment, ObserverEnrollment, or DesignerEnrollment) and return the created enrollment object, including its `id` and `enrollment_state`. Use `list_course_enrollments` with a `user_id` filter to check a user's existing enrollments before enrolling them again, and `remove_enrollment` to conclude, deactivate, or permanently delete this enrollment afterward — `enroll_user` itself has no way to undo what it creates. Omitting `enrollment_state` leaves it at Canvas's documented default of "invited", so the user mu…

Recomputes and explains the weighted course grade for a student, including assignment-group weights, drop_lowest / drop_highest / never_drop rules, per-group breakdowns (earned points, dropped assignments, weighted contributions), the mapped letter grade (via the course grading standard when present), and a reconciliation check against Canvas's posted current_score / final_score. Use this when you need to verify that Canvas's displayed grade matches the rules, or to explain to a student or instructor how their grade was calculated. Limitations: - V1 computes one student per call. Omit studen…

Explains the grading automation rules configured for a Canvas course: - Missing-submission policy: whether blank/unsubmitted work is automatically scored 0 (or another deduction), or left unpenalised. - Late-submission policy: whether Canvas applies a per-day or per-hour percentage deduction to late submissions, and whether there is a floor below which the grade cannot fall. - Assignment-group weighting: whether the course uses weighted groups, and the weight of each group. - Grading scheme: whether a letter-grade scheme (A/B/C/F mapping) is applied to the final score. Also returns a plain-la…

Find duplicate files in a course's Files area — copies with the same name and size, typically left behind by repeated course copies. Each duplicate gets flagged separately by accessibility checkers, so this surfaces them for cleanup with the existing delete_file tool. Groups by display name + size (Canvas file listings carry no content hash), so same-name files of different sizes are not considered duplicates.

Search the caller's teaching courses — active and, by default, concluded (past-term) ones — for a student by name, login, or email, and report every matching course with the student's enrollment state and last activity. Set `include_concluded: false` to only search current courses. `max_courses` bounds how many of the caller's courses are scanned (most recent term first); when exceeded, `truncated: true` is set rather than silently dropping courses. A course that errors during the scan is skipped and reported in `courses_failed` rather than failing the whole call.

Get a single Canvas account by ID, including its name, parent and root account IDs, UUID, default storage quotas, and workflow state. Find the account_id via `list_accounts`, or `list_sub_accounts` on a parent account to find one of its children. Requires an admin role on the account.

List the report types a Canvas account supports — csv/grade exports, SIS imports, and institution-specific types — each with its report key, title, expected parameters, and the most recent `last_run` status if one was ever generated. This only lists what can be run; it does not start, re-run, or download a report, and there is no report-running tool registered on this server. Use `get_account` to confirm the account first. Requires an admin role on the account.

Get a single appointment group's core record — id, title, context_codes, workflow_state, and location — by id. None of its time slots, per-slot reservations, or participant counts come back unless you pass include with "appointments", "child_events", or "participant_count" respectively; omit include and you get only the core record. Find the id with list_appointment_groups. Use list_appointment_group_users or list_appointment_group_groups to see who has actually reserved a slot, and next_appointment to find the next slot still open to sign up for.

Get the full assignment record for one assignment by ID, including every `include` extra requested. Get the assignment_id from list_assignments, which also supports fields="slim" for scanning many assignments before fetching one here in full. `include` adds submission (the current user's own), assignment_visibility, overrides, observed_users, can_edit, and score_statistics — each omitted from the response unless requested.

Get score distribution analytics for assignments in a course. Returns statistical summary (min, max, median, first/third quartile), submission count, and tardiness breakdown (on_time, late, missing) for each assignment. Provide assignment_id to scope to one assignment; omit to return analytics for all assignments in the course.

Get the status of a content export. When workflow_state is "exported", attachment.url contains a time-limited download link — download it promptly, as the URL expires (re-fetch to get a fresh one). Returns attachment: null while still "created"/"exporting" or on "failed".

Get the status of a single content migration. When workflow_state is "running", poll progress_url for live updates. When "completed", the migration is done.

Get one conversation's full message thread by id, returning its subject, participants, and every message (id, body, author_id, created_at) — not just the last_message summary list_conversations returns. Canvas marks any unread messages in this thread as read as a side effect of calling this, so re-reading a thread changes its unread state. Find the conversation_id with list_conversations. Use get_conversation_unread_count to check the inbox-wide unread total without marking anything read.

Get the number of unread conversations for the authenticated user as a single integer — not the conversations themselves, and not a count of unread messages within them. Use list_conversations to see which conversations are unread, or get_conversation to open one and mark its messages read.

Get details for a single course. Defaults to requesting `term` and `total_students`. Pass `include` to replace the default set with custom Canvas include[] fields (teachers, permissions, syllabus_body, sections, etc.).

Get a summary of recent activity in a course. Returns counts of recent events grouped by type (submissions, discussions, announcements, etc.).

Get course-level activity analytics. Returns daily page view and participation counts.

Return the full module → items tree for a course in a single call, with summary stats. Avoids N+1 round-trips when an agent needs to reason over the whole course shape.

Get the current user's dashboard course cards with position, color, and image.

Get a single discussion topic in a course by ID, returning its title, message, posted_at, discussion_type, published state, and is_announcement, plus due/available dates via Canvas's all_dates include. Find topic_id with list_discussions. Course-scoped only — use get_group_discussion for a topic that belongs to a group instead of a course.

Get metadata for a single file by ID, including download URL.

Get the graders and assignment IDs that had gradebook activity on a specific course date.

Get the paginated gradebook history feed for a course, optionally filtered by assignment or user and optionally sorted oldest-first.

Get a single discussion topic in a group by ID, returning its title, message, posted_at, discussion_type, published state, and is_announcement, plus due/available dates via Canvas's all_dates include. Find topic_id with list_group_discussions. Group-scoped only — use get_discussion for a topic that belongs to a course instead of a group; there is no group-scoped counterpart to post_discussion_entry, so this server cannot post a reply to a group topic yet.

Get the old-to-new asset ID mapping for a completed migration. Useful for resolving references to content that existed in the source course.

Get the selective import tree for a migration — the list of content items available to selectively import. Only meaningful for migrations in the "waiting_for_select" state.

Get assignments with missing submissions for the current user.

Get a single module by its Canvas ID, including its name, position, publication state, unlock date and item count, but not the item list itself. Find the module_id via `list_modules` or `get_course_structure`. Use `list_module_items` to see what is inside, or `view_course_structure` for an interactive tree of every module in the course.

The authenticated student's cross-course activity stream: new discussion posts, announcements, conversation messages, graded submissions, peer-review requests and conference invitations from every course at once, newest first. Four caveats, none of them visible in the response: (1) RECENT ACTIVITY ONLY — typically the last ~4 weeks; the retention window is a per-Canvas-instance setting and cannot be read through the API, so "nothing found" is not evidence that nothing happened. (2) Each item's `message` was truncated to 4096 characters when Canvas stored it, with no marker — follow the item's …

Count unread and total items in the authenticated student's cross-course activity stream, grouped by Canvas item type (e.g. DiscussionTopic, Announcement, Submission, Conversation). No item content — counts only. A good first call in a daily workflow to check "is there anything to look at?" before fetching the full stream.

What the authenticated student still has to DO in one course: a per-module requirement graph where every row names the Canvas endpoint and field its verdict came from. Richer than list_modules plus list_module_items, which return a raw `completion_requirement` without the cross-references that make it truthful; for grade outcomes use project_grade or explain_grade instead, and for cross-course context list_my_planner_items. Five things to read before acting on the output: (1) `unknown` is a real state and is NOT "unsatisfied" — Canvas attaches `completion_requirement.completed` only where it l…

List active courses for the authenticated student.

Get grade data for the authenticated student. If course_id is omitted, returns grades across all enrolled courses.

List the authenticated student's own submissions that carry feedback comments from an instructor or a peer reviewer — comments left by the student themselves do not count as feedback and submissions with no non-self comments are omitted. Omit `course_id` to scan every active course; a course that errors during a scan is skipped and reported in `courses_failed` rather than failing the whole call. Sorted most-recent-feedback-first. Comment author role is best-effort: 'teacher' is only identified when the author is the submission's recorded grader; other non-self authors are labeled 'peer', inclu…

List all submissions for the authenticated student in a course.

List upcoming assignment events for the authenticated student. Canvas caps this endpoint at roughly the next 1 week and at most 20 events server-side — neither limit is adjustable, and results silently stop there even if more assignments fall later. For a longer or specific date range, use `list_calendar_events` with `type="assignment"` and explicit `start_date`/`end_date` instead.

Get one item (question or stimulus) from a New Quiz (LTI) by its item_id, returning its position, points_possible, entry_type, and full entry body — including interaction_data and scoring_data, so the response reveals the correct answer. Find item_id with list_new_quiz_items, which also lists every item at once; use this tool only to refetch one item, such as right after create_new_quiz_item or update_new_quiz_item. assignment_id identifies the New Quiz (from list_assignments or get_assignment, filtered on is_quiz_lti_assignment), not a Classic Quiz ID.

Get the full details for one learning outcome by outcome_id, including its rating criteria, mastery_points, and calculation_method. The outcome_id comes from list_outcome_group_outcomes, list_outcome_group_links, or get_outcome_results' / get_outcome_rollups' linked.outcomes; get_outcome_alignments lists all alignments in the course (not scoped to one outcome) — cross-reference via get_outcome_results instead to tie an alignment to this outcome_id.

Get the assignments aligned to outcomes in a course, optionally filtered to one student_id or assignment_id. Returns each alignment's assignment_id and title, but not the outcome_id it maps to. get_outcome_results nests the same alignment objects under linked.alignments, but ties an alignment to an outcome via each outcome_results[] entry's links.alignment and links.learning_outcome, not from linked.alignments alone. Use get_outcome_contributing_scores to see the assignment scores that produced an outcome's results instead of just the links.

Get the assignment or quiz scores that contributed to one outcome_id's results for one or more students in a course, optionally restricted to assignment alignments only or including unpublished assignments. Use get_outcome_results instead for the final per-alignment outcome score rather than the scores that fed it, or get_outcome_alignments to list all alignments in the course (not scoped to this outcome) without their scores.

Get the full details for one outcome group by outcome_group_id within an account or course context, including its subgroups_url and outcomes_url. The ID comes from list_outcome_groups, list_outcome_group_subgroups, or get_root_outcome_group; use list_outcome_group_outcomes to list the outcomes linked under this group and list_outcome_group_subgroups to list this group's child groups.

Get a mastery-level histogram for outcomes in a course — how many students fall into each rating band — optionally filtered by outcome_ids and student_ids and excluding missing user rollups or missing outcome results. Set include_alignment_distributions to also break down scores by contributing alignment. Use get_outcome_rollups instead for each student's individual aggregated score, or get_outcome_results for the raw per-alignment scores.

Get raw per-student, per-alignment outcome results for a course (one score per assessed alignment, not aggregated), optionally filtered by user_ids, outcome_ids, and include_hidden. Set include_alignments to nest the matching alignments under linked.alignments. When CANVAS_PSEUDONYMIZE_STUDENTS is enabled, linked.users entries are anonymized; use resolve_pseudonym to map one back to a real user. Use get_outcome_rollups instead for aggregated scores per student and outcome, or get_outcome_contributing_scores for the assignment or quiz scores behind one outcome.

Get aggregated outcome rollups for a course — one score per student per outcome, or, with aggregate="course", a single course-level mean or median — optionally filtered by user_ids and outcome_ids and sorted by student or by one outcome's score. Set include_courses to nest course details under linked.courses. When CANVAS_PSEUDONYMIZE_STUDENTS is enabled, linked.users entries are anonymized; use resolve_pseudonym to map one back to a real user. Use get_outcome_results instead for the raw per-alignment scores behind a rollup, or get_outcome_mastery_distribution for a mastery-level histogram acro…

Get one wiki page by its page_url slug — not a numeric ID — obtained from list_pages. Returns the page's title, published state, editing_roles and full HTML body, unlike the list endpoint's body-less stubs. Use list_pages to discover a course's pages and find a page_url, and update_page to edit this page's title, body, published state or editing_roles afterward.

Get the profile of the currently authenticated user.

Get one quiz by ID, found with list_quizzes. If the ID belongs to a New Quiz, Canvas returns only its stub row (quiz_type: quizzes.next) — use list_new_quiz_items for the actual question content. Returns title, quiz_type, points_possible, question_count, due_at, published state, and assignment_id (the graded assignment Canvas created for this quiz; null for an ungraded survey or practice quiz). Use list_quiz_questions for a Classic quiz's fixed questions and list_quiz_submissions for student attempts.

Review every student's answer to one or all questions in a Classic Quiz, pivoted by question instead of by student — for grading essay/short-answer/file-upload questions consistently across a class instead of paging through SpeedGrader one student at a time. Classic Quizzes only (quiz_type: assignment, practice_quiz, graded_survey, survey) — New Quizzes exposes responses through a different API. Omit question_id to get every question; provide it to scope to one. Each question reports needs_manual_grading (true for essay and file-upload questions) and points_possible. Questions drawn from a que…

Get a quiz submission's state for an IN-PROGRESS (untaken) attempt, including the student's live answer and flag per question. For a SUBMITTED attempt (complete or pending_review), Canvas never returns the answer value or a real flag state through this endpoint — only grading state (correct) is available here. To review a submitted attempt's actual answer text, use get_quiz_question_responses instead.

Get the event log for a Classic Quiz submission in chronological order. Events include session_started, question_answered, question_flagged, page_blurred, and page_focused. Use this to understand the timeline of a student's attempt. Classic Quizzes only — New Quizzes does not expose event logs via the Canvas REST API. Events are scoped to a single submission; Canvas enforces access permissions (instructors and the submitting student only). Do not use event logs as the sole basis for academic-integrity conclusions; present them with context.

Get the root outcome group for an account or course context, the entry point into the outcome tree. Returns the top-level outcome group (id, title, subgroups_url, outcomes_url); walk from there with list_outcome_group_subgroups for its child groups and list_outcome_group_outcomes for outcomes linked directly under a group, or use list_outcome_groups for a flat listing of every group in the context instead of walking the tree.

Get a single rubric's definition (title, points_possible, criteria, and rating levels) by ID. Use list_rubrics to find the rubric_id for a course first. Pass include=["assignment_associations"] to also retrieve the rubric association IDs that submit_rubric_assessment needs, or include=["assessments"|"graded_assessments"|"peer_assessments"] for assessor_id-only assessment summaries (no assessor name is returned). This returns the rubric's structure, not any one student's completed assessment — use get_rubric_assessment for that. Requires the manage_rubrics permission in the course, so most stud…

Get one student's submission for an assignment with the Canvas rubric_assessment attached, keyed by criterion_id (rating_id, comments, points per criterion) — this does not carry the assessor's name or any grader identity. This is the same full submission object (score, grade, workflow_state, submitted_at) that get_submission returns, requested here with `include[]=rubric_assessment` instead of get_submission's default `submission_comments`; use get_submission when you also need comments or the submitted text/URL. Use submit_rubric_assessment to post a rubric assessment for a student rather th…

Get per-student activity analytics for a course. Returns page views, participations, and submission timeline for a specific student.

Get one student's submission for an assignment by user_id, returning the Canvas submission object (score, grade, workflow_state, submitted_at, body/url, submission_comments). user_id can be any user in the course, not only the caller's own. Use list_submissions to fetch every student's submission for the assignment in a single call instead of one get_submission call per student, or get_my_submissions when the caller wants their own submissions across a whole course rather than one assignment. Defaults to including submission_comments; pass `include` to add submission_history, rubric_assessment…

List the peer reviews assigned to one submission within an assignment — a single submission can have more than one assigned reviewer — returning each review's id, assessor_id (the reviewer), user_id (the reviewee), asset_id, and workflow_state ('assigned' or 'completed'). Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Use list_peer_reviews instead to see every review assigned across the whole assignment rather than one submission, create_peer_review to assign another reviewer to this submission, and delete_peer_review to rem…

Get just the syllabus HTML body for a course, returning { course_id, syllabus_body } where syllabus_body is null if the course has none set. Use get_course with include: ['syllabus_body'] instead when you also need other course fields in the same call, or update_course to change the syllabus body. If the course has public_syllabus or public_syllabus_to_auth enabled, the body may be readable even by callers without an enrollment in the course.

Get the current user's to-do items, including upcoming assignments and grading tasks.

Get the current user's upcoming calendar events and assignments. Canvas caps this endpoint at roughly the next 1 week and at most 20 events server-side — neither limit is adjustable, and results silently stop there even if more events fall later. For a longer or specific date range, use `list_calendar_events` with explicit `start_date`/`end_date` instead. Canvas does not support filtering this endpoint server-side; `type` filters the returned items client-side by their own `type` field ("event", "assignment", or "sub_assignment") instead.

Get a single Canvas user by numeric ID, returning the full Canvas user object (name, email, login_id, time_zone, bio, pronouns) when the caller is permitted to see it. Use get_profile instead when the target is the caller's own account, search_users to find a user when you only know their name, login, or email in an account, or list_course_users to see every user enrolled in a specific course. Because a bare ID lookup carries no enrollment data, pseudonymized mode cannot tell staff from students here and conservatively anonymizes the name and email on every call; list_course_users only keeps a…

Post or update the grade for one student's submission on a regular assignment and return the updated Canvas submission object (score, grade, workflow_state, graded_at). Only `grade` is sent; nothing else on the submission changes. Idempotent: calling it again with the same grade string overwrites the previous `posted_grade` rather than creating a second grade. This sets only the top-level grade — for a rubric-based assignment use submit_rubric_assessment to score each criterion instead, and for a Classic Quiz use score_quiz_question to grade one question at a time rather than the assignment as…

Check if the Canvas API is reachable and the token is valid. Returns ok/error status.

List every course in a Canvas account, optionally filtered by `search_term` matching course name or course code. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Use `list_sub_accounts` first if you want one sub-account's courses rather than this account's own, and `list_courses` instead for the courses the authenticated user is enrolled in or can access, rather than a full account inventory. Requires an admin role on the account.

List active global institution-wide announcements for the current user (maintenance windows, term deadlines, policy notices).

List every user in a Canvas account — every role the account contains, not only students — optionally filtered by `search_term` matching name, email, or login. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Use `include` to add email, last_login, avatar_url, time_zone, or uuid to each returned user, `sort`/`order` to control result ordering (`sort: "id"` is Canvas's recommended choice when paging through many results), and `list_course_users` to scope the roster to one course rather than the whole account. When CANVAS_PSEUDO…

List all accounts accessible to the authenticated user.

List announcements in a course, returning id, title, message, and posted_at for each one. Canvas serves this from the same discussion_topics index as list_discussions, filtered to topics marked is_announcement via the only_announcements query parameter. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Use create_discussion with is_announcement: true to post a new announcement, and update_discussion to edit one afterward.

List the student groups that have a reservation in this appointment group, returning each as a group object (id, name, group_category_id, members_count) — the same shape list_groups returns. Only meaningful when the group's participant_type is "Group" — a User-type group returns an empty list here; use list_appointment_group_users instead for those. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Find the appointment_group_id with list_appointment_groups.

List the individual Canvas users who have a reservation in this appointment group, returning each as a user object (id, name). Only meaningful when the group's participant_type is "User" — a Group-type group returns an empty list here; use list_appointment_group_groups instead for those. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Find the appointment_group_id with list_appointment_groups, or use get_appointment_group with include=["participant_count"] for just a count instead of the full list.

List appointment groups (Canvas Scheduler sign-up slots) visible to the current user, returning each group's id, title, context_codes, workflow_state, and location — time slots, per-slot reservations, and participant counts are each left out unless you pass the matching include value. scope defaults to "reservable" (groups the user is eligible to sign up for; reserving a slot itself happens in the Canvas UI, not through this server) and can be set to "manageable" for the groups the user administers. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of…

List assignment groups (categories like Homework, Exams) in a course. Use `include=assignments` to nest assignments under each group; other includes add submission, overrides, score_statistics, etc.

List all due-date / availability overrides for a specific assignment in a course. Returns overrides targeting individual students, sections, or groups. Useful for auditing before creating a new override — Canvas returns a 422 if a student-set override already exists for the same students on the same assignment.

List all assignments in a course. Use fields="slim" when enumerating assignments for selection; switch to "full" once you've identified the target. slim returns id, name, due_at, points_possible, published, and course_id only. "full" (default) includes all Canvas fields plus `include` extras (submission, all_dates, overrides, score_statistics, etc.). Use `bucket` to filter by past/upcoming/overdue/etc. Other filters: `search_term`, `assignment_ids`, `order_by`.

List calendar events for a course, unbounded by the ~1-week/20-item caps that `get_upcoming_events` and `get_my_upcoming_assignments` are stuck with. By default Canvas only returns `type="event"` items for today alone (end_date defaults to start_date) — pass both start_date and end_date to cover a range, and type="assignment" to list assignment due dates instead of plain events.

List all content exports for a course (most recent first).

List available migration types (migrators) for a course. Returns migrator type keys such as course_copy_importer, common_cartridge_importer, zip_file_importer, qti_converter, moodle_converter.

List all content migrations for a course (most recent first).

List the authenticated user's inbox: every non-archived conversation, both read and unread, newest first, returning each one's id, subject, last_message, last_message_at, message_count, and participants (id, name) — no message bodies; use get_conversation for the full thread. There is no scope filter here, so starred-only, archived, sent-only, or unread-only views aren't available. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Use get_conversation_unread_count for just the unread total instead of the whole inbox.

List enrollments within a specific course with Canvas filters. Use `include=grades` / `include=current_points` for richer grade data, `type[]` to limit to a role, and `user_id` to focus on a single user.

List every file attachment submitted by students across all assignments in a course. Returns a manifest — one entry per file — including the original filename, a file_id for re-fetching via download_file, content type, and size. Useful for bulk-archiving student work before a course expires or a Free-For-Teacher account is concluded. Outputs are bounded by max_files (default 500); when the limit is hit, truncated is true and truncation_note explains how to retrieve the rest. Download URLs are time-limited (typically 1 hour) — use the returned file_id with download_file to get a fresh URL at do…

List users in a course with optional Canvas filters. Use `include` to request email, enrollments, avatar_url, bio, and other fields otherwise omitted from the default response. Use `enrollment_type` / `enrollment_state` to narrow by role or status, `search_term` to filter by name/login, `user_ids` to fetch a specific subset, and `sort`/`order` to control ordering.

List courses for the authenticated user. Use fields="slim" when enumerating courses for selection; switch to "full" once you have identified the target. slim returns id, name, course_code, term name, and workflow_state only. "full" (default) includes all Canvas fields plus `include` extras (teachers, total_students, syllabus_body, etc.). `state[]` narrows by course workflow state; `enrollment_state` narrows by the caller's enrollment state.

List discussion topics in a course, returning id, title, message, posted_at, discussion_type, published, and is_announcement for each topic — replies are not included. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Use get_discussion to fetch one topic in full detail including due/available dates, post_discussion_entry to reply, and list_announcements to see only announcements.

List every enrollment the authenticated user holds across all of their Canvas courses — the caller's own enrollments only. Use `list_course_enrollments` for a single course's full roster, including a `user_id` filter to focus on one person. Optional `type`, `state`, and `role` filters and the `include` array mirror Canvas's own `GET /users/self/enrollments` endpoint. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. When pseudonymization is enabled, each enrollment classified as student or unknown has its nested `user` object r…

List every file in a course's Files area, returning metadata only — name, size, content type, folder_id, and the Canvas-hosted download URL — not the file's content. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Use download_file to fetch a file's actual content, get_file to refetch a single file's metadata by ID, list_folders for the folder tree these files sit in, and find_duplicate_files to spot same-name-and-size copies left over from course copies.

List every folder in a course's Files area, including each folder's name, full path, parent_folder_id, and file/subfolder counts, but not the files or subfolders inside each one. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Use list_files to see the files inside a folder, and upload_file's `parent_folder_path` to place a file in — and implicitly create — a folder path that doesn't exist yet; Canvas creates any missing segment along the way rather than requiring it to already exist.

List the dates in a course gradebook history that contain grading activity, grouped by grader and assignment.

List versioned submission history for one grader and assignment on a specific gradebook history date.

List grading standards available in a course or account context. Provide either course_id (to see standards scoped to a course) or account_id (to see account-level standards, requires admin access). Returns an array of grading standard objects, each with an id, title, context, and grading_scheme array of { name, value } entries.

List the group categories (group sets) in a course. A group assignment points at a category through its group_category_id, and create_group needs a category ID, so use this to find one.

List discussion topics in a group, returning id, title, message, posted_at, discussion_type, published, and is_announcement for each topic — replies are not included. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Use get_group_discussion to fetch one topic in full detail including due/available dates, and list_discussions for the course-scoped equivalent; there is no group-scoped counterpart to post_discussion_entry or list_announcements.

List all members of a group.

List all groups in a course.

List issues encountered during a content migration. Each issue has a type (todo, warning, or error) and a description.

List every item in one module — Assignment, Page, Quiz, File, Discussion, ExternalUrl, ExternalTool or SubHeader — in module order, including each item's `published` state and unpublished items. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Use `list_modules` to find the module_id, `get_course_structure` for every module's items in one call, and `create_module_item`, `update_module_item` or `delete_module_item` to change what is inside.

List all modules in a course, including each module's name, position, publication state, unlock date and item count, but not the items inside. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Use `list_module_items` or `get_course_structure` to see what is inside each module, and `get_module` to fetch one module by ID.

The authenticated student's planner: assignments, ungraded quizzes, planner notes, wiki pages, ungraded discussions, calendar events, peer reviews, sub-assignments and peer-review sub-assignments — everything with a due or to-do date, across every course and group at once. Strictly richer than get_todo_items, which covers only assignments needing submitting or grading. Four caveats: (1) start_date and end_date must be given TOGETHER or OMITTED TOGETHER — supplying only one makes Canvas silently default the other side to a ten-year window, so a half-specified range is rejected outright; omittin…

List every item (question or stimulus) in a New Quiz (LTI), in quiz order, returning each item's id, position, points_possible, entry_type, and full entry body — including interaction_data and scoring_data, so the correct answer is visible in the result. Find the assignment_id with list_assignments or get_assignment, filtered on is_quiz_lti_assignment (not a Classic Quiz ID). Use get_new_quiz_item to refetch a single item by id, create_new_quiz_item to add one, update_new_quiz_item to change one, and delete_new_quiz_item to remove one. Fetches every page (100 per request) and fails with a 'Res…

List every outcome link in an account or course context — the many-to-many join between outcome groups and the outcomes they contain, read from the context root, not one specific group. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Each link nests its outcome_group and outcome (full detail when outcome_style="full" / outcome_group_style="full", abbreviated otherwise); use list_outcome_group_outcomes instead to list only the outcomes linked directly under one specific outcome_group_id.

List the outcomes linked directly under one outcome group (outcome_group_id), not its subgroups' outcomes. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Each link nests the outcome (full detail when outcome_style="full", abbreviated otherwise); use list_outcome_group_subgroups to descend into child groups first, or get_outcome for one outcome's full detail by outcome_id.

List the immediate child outcome groups under one outcome group (outcome_group_id) — one level of the tree, not a recursive walk. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Call this again with each returned group's id to descend further, or use list_outcome_group_outcomes on the same outcome_group_id to list outcomes linked directly under it instead of its child groups.

List every outcome group in an account or course context as a flat array, not a tree. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Use get_root_outcome_group plus list_outcome_group_subgroups to walk the hierarchy instead, or get_outcome_group to fetch one group's details by ID.

List every wiki page in a course, returning page stubs — title, url slug, published state and editing_roles — without the HTML body; the paginated list endpoint omits body entirely. Use get_page to fetch one page's full body by its url slug, or search_course_content to search page content across the whole course. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating.

List every peer review assigned on an assignment, across every submission, returning each review's id, assessor_id (the reviewer), user_id (the reviewee whose submission is being reviewed), asset_id, and workflow_state ('assigned' or 'completed'). Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Pass submission_id to scope the results to the reviews assigned to that one submission instead of the whole assignment — the same result get_submission_peer_reviews returns, kept here as a shortcut. Omit it to see every review across t…

List the fixed questions defined on a Classic quiz — id, position, question_text, question_type, points_possible, and answers — in quiz order. This is the quiz's static question list only: it does not include the generated questions Canvas serves per attempt when a question-bank draw is configured, and it carries no student answer data. Find the quiz_id with list_quizzes or get_quiz. Use get_quiz_question_responses to see what each student was actually served and answered, including bank-drawn questions, and score_quiz_question to grade an answer. Fetches every page (100 per request) and fails…

List every submission (one row per student's attempt history) for a Classic quiz, including each submission's score, kept_score, workflow_state, and any extra_time / extra_attempts accommodation Canvas has recorded for that student. Find the quiz_id with list_quizzes or get_quiz. To see a submission's actual answers, use get_quiz_submission_answers for an in-progress attempt or get_quiz_question_responses for a submitted one; to change a score use score_quiz_question. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating.

List every quiz row in a course, including the New Quiz stub Canvas mixes into the same list (quiz_type: quizzes.next, with no question or submission detail of its own). Use quiz_type to tell Classic Quizzes (assignment, practice_quiz, graded_survey, survey) apart from New Quizzes, and list_new_quiz_items for a New Quiz's actual questions. Returns each quiz's title, quiz_type, points_possible, question_count, due_at and published state. Use get_quiz to fetch one quiz by ID, list_quiz_questions for its fixed questions, and list_quiz_submissions for student attempts. Fetches every page (100 per …

List every rubric defined in a course, returning each rubric's title, points_possible, and criteria/ratings. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Use get_rubric to fetch one rubric by ID once you have it, get_rubric_assessment for a specific student's completed assessment rather than the rubric definition, or create_rubric to add a new one. Requires the manage_rubrics permission in the course, so most students cannot call this.

List the sections of a course, returning each section's id, name, course_id, start_at, end_at and restrict_enrollments_to_section_dates. Use it to resolve the section ID that `create_assignment_override` needs for a section-specific due date, that `enroll_user` takes as `course_section_id`, and that the `needs_grading_count_by_section` option on `list_assignments` reports against; use `list_course_enrollments` or `list_course_users` for the people in a section rather than the sections themselves, or `get_course` with include: ['sections'] when you also need other course fields in the same call…

Read the current course-level New Quizzes accommodation (time multiplier and/or extra attempts) for a specific student in a course. Useful for auditing before or after calling set_student_new_quiz_accommodation. Returns has_accommodation: false when no accommodation is set (Canvas 404 is treated as "no record", not an error). New Quizzes store a single course-level accommodation record per student; this is not per-quiz. For Classic Quizzes, use list_student_quiz_accommodations instead. Provide user_id as the real Canvas user ID. If CANVAS_PSEUDONYMIZE_STUDENTS is enabled, call resolve_pseudony…

List the current quiz accommodation (extra time and/or extra attempts) for a specific student across all Classic Quizzes in a course. Useful for auditing before or after calling set_student_quiz_accommodation. New Quizzes (quiz_type quizzes.next) are excluded. Reads extra_time / extra_attempts from each quiz's submission records (Canvas exposes no read endpoint for quiz extensions directly) — one Canvas API call per Classic Quiz, so it may be slow for courses with many quizzes. Errors from any quiz's read propagate immediately (no per-quiz error catching). Provide user_id as the real Canvas us…

List every student enrolled in a course (enrollment_type=student only), returning Canvas user objects (id, name, email, login_id) without grades or enrollment details. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Use list_course_users for every role in the course (teachers, TAs, observers) or to filter users by enrollment_state, and list_course_enrollments when you need the enrollment/grade objects themselves (score, grade, enrollment workflow_state) rather than user profile fields. In pseudonymized mode every returned use…

Report students who may need instructor attention based on inactivity, missing or late submissions, and low current score. Each finding lists the exact signals that fired and the thresholds used — this is a factual report, not a prediction. Requires instructor/TA permissions in the course.

List the direct child accounts nested under a given Canvas account — one level deep, not grandchildren or deeper descendants. Fetches every page (100 per request) and fails with a 'Results are incomplete' error instead of silently truncating. Use `get_account` to fetch one sub-account's full details by ID, or call this tool again with a child's ID as `account_id` to walk further down the tree. Requires an admin role on the account.

List submissions where the most recent comment is from the student and has not been addressed by grading or a reply — i.e. comments the instructor has likely not seen. Returns a triage list, oldest-unaddressed first. Requires instructor/TA permissions in the course.

List all submissions for an assignment. Use `include` to attach user, assignment, rubric_assessment, submission_history, or visibility. Filter with `student_ids`, `workflow_state`, or `grading_period_id`. Defaults to including submission_comments.

Lists all submissions in a course that still need a human grade, sorted oldest-waiting first. Surfaces two categories: - workflow_state=submitted: assignments submitted by students but not yet graded at all. - workflow_state=pending_review: Classic Quiz submissions where Canvas auto-graded the objective questions but left essays or manually-scored questions for the instructor. Returns a triage list grouped by assignment or Classic Quiz, with per-submission details: student identity, workflow state, submitted_at, and whether the submission has pending manual-grading questions. Parameters: - …

Get the single next open time slot the current user is still eligible to sign up for, searched across every appointment group the user can reserve in (or only the appointment_group_ids you pass), and return it as a one-element array of calendar-event objects — or an empty array if nothing is open. This is about availability, not history: it excludes slots the user already reserved and slots that are full, but does not exclude a whole group just because the user holds a reservation in one of its other slots. Use list_appointment_groups with scope="reservable" to browse every open group instead …

Post a new entry (reply) to a discussion topic in a course, and return the created entry (id, user_id, message, created_at). Not idempotent: each call adds another reply, Canvas does not deduplicate repeated calls. Works even on a topic Canvas has made anonymous, where get_discussion itself 404s — use list_discussions to confirm the topic exists and find its topic_id. Requires the caller to have an active enrollment in the course with permission to post to the forum, which Canvas grants to students, TAs and instructors by default unless an admin has restricted it.

Projects the minimum score needed on remaining assignments to reach a target course grade. Given a target (as a percentage, e.g. 90, or a letter grade, e.g. "A") and the student's current scores, computes the minimum uniform percentage that must be earned on all remaining (not yet graded) assignments for the overall course grade to reach the target. Accounts for assignment-group weights, drop_lowest / drop_highest / never_drop rules, and the course grading scheme (for letter-grade targets and output letter mapping). Returns: - minimum_pct_on_remaining: the uniform percentage needed on all re…

Remove or conclude an enrollment from a course. The 'delete' task is permanent; 'conclude' and 'deactivate' are reversible.

Remove a user from a group. The user stays enrolled in the course. Reverse with add_group_member.

Resolve a stable pseudonym (e.g. "Student 7") back to a Canvas user_id within a course. Use only when a teacher has explicitly asked to identify a specific student in an artifact. Every call is audit-logged.

Set the score and an optional feedback comment for one question in one student's Classic quiz submission, overwriting any existing score for that question on the chosen attempt — it replaces the question's recorded score rather than adding to it, so calling again with the same score and comment leaves the submission unchanged. Omit attempt to score the latest attempt. Find submission_id with list_quiz_submissions and question_id with list_quiz_questions or get_quiz_question_responses. Returns { success: true }; Canvas does not hand back the updated submission to this endpoint. Requires grading…

Search for content within a course. Searches pages, assignments, discussions, and announcements by keyword.

Search for users in a single Canvas account by name, login, or email, returning matching Canvas user objects. Use `include` to add email, last_login, avatar_url, time_zone, or uuid to each result, and `sort`/`order` to control the ordering. This is one account-scoped search — to check whether one student is enrolled anywhere across an educator's own active and concluded courses, use find_student_across_courses instead; to list every user in one course without a search term, use list_course_users; to list an entire account's users unfiltered, use list_account_users. Because results carry no enr…

Send a new message and return the created conversation object(s) (id, subject, participants) — one per recipient. With more than one entry in recipients, this creates a separate private conversation with each recipient rather than one shared group thread: each recipient sees only their own copy, and nobody sees who else received it. Every call sends again — there is no dedup against an already-sent message with the same subject and body. recipients must be real Canvas user ids as strings; list_course_users or search_users can look those up first. Requires the authenticated user to have permiss…

Fan a due-date / availability override for a specific student across all (or a filtered subset of) assignments in a course. Creates one student-set override per assignment via the Canvas assignment overrides API. Partial failures are tolerated — a failure on one assignment does not abort the rest. Note: for courses with many assignments this makes one Canvas API call per assignment. V1 is create-only: if an override for this student already exists on an assignment, Canvas returns a 422 and that assignment appears in the failed[] list. Use list_assignment_overrides to audit first. Dates must be…

Apply a time and/or attempts accommodation for a student across all New Quizzes in a course (course-level, single Canvas API call when no assignment_ids are given) or for a specified subset of New Quizzes (per-quiz fan-out when assignment_ids are given). New Quizzes use a time_multiplier (ratio, e.g. 1.5 for 1.5× time), not absolute minutes. For Classic Quizzes (quiz_type: assignment / practice_quiz / etc.) use set_student_quiz_accommodation instead. Partial per-quiz failures are tolerated — a failure on one quiz does not abort the rest. In per-quiz mode, fan-out is sequential (one Canvas API …

Apply extra time and/or extra attempts to a specific student across all Classic Quizzes in a course (or a specified subset). Fans out to the Canvas quiz extensions API for each quiz. New Quizzes (quiz_type quizzes.next) are skipped — use set_student_new_quiz_accommodation instead. Only applies to quizzes that exist at call time; re-run after creating new quizzes. Assignment due-date overrides are not handled here (separate fast-follow feature). Note: for courses with many quizzes this makes one Canvas API call per quiz. Partial failures are tolerated — a failure on one quiz does not abort the …

Submit the authenticated student's own work to an assignment. Opt-in tool: only available when the server was started with CANVAS_ENABLE_ASSIGNMENT_SUBMISSION. IMPORTANT: before calling, show the user exactly what will be submitted (assignment name, submission type, and full content/URL/file list) and get their explicit confirmation — submissions cannot be retracted and may consume a limited attempt. Submits as the token holder only; submitting on behalf of another user is not supported. For online_upload, first upload each file with upload_submission_file and pass the returned file ids.

Submit a rubric assessment with scores and comments for each criterion.

Update an existing appointment group by id — only the fields you pass are changed — and return the updated group object. Set publish=true to make a draft group visible to participants; Canvas will not let you set it back to false once published. Add new_appointments as [start_at, end_at] ISO 8601 pairs to create additional time slots — existing slots are left alone and there is no removal here. This tool cannot change participant_type, participant_visibility, or the per-participant appointment limits set at create_appointment_group; those are fixed at creation. Find the id with list_appointmen…

Update an existing assignment in a course, changing only the fields you pass — anything omitted keeps its current value — and return the updated assignment object. Calling this again with the same arguments leaves the assignment in the same state, unlike create_assignment, which always makes a new one; use delete_assignment to remove this assignment instead. due_at, lock_at, and unlock_at set here apply to every student without an override; use create_assignment_override for a different date for one section, group, or set of students, or set_student_assignment_dates to fan one student's date c…

Update an existing assignment group in a course and return the updated Canvas assignment group object. Only the fields passed are changed — anything omitted keeps its current value, so repeating the same call leaves the group in the same state, unlike `create_assignment_group`, which always makes a new group. Use it to repair a weighted gradebook: `group_weight` sets the group's percent of the final grade (which changes nothing unless the course is set to weight its final grade by assignment group — a course setting `update_course` can turn on), and `rules` drops the lowest or highest scores i…

Update an existing calendar event. Only provided fields are changed.

Update an existing course and return the updated Canvas course object. Only the fields you pass are changed; omitted fields are left as-is, and calling it again with the same values leaves the course in the same state (idempotent). Requires permission to update course details; a caller who has only that lesser permission (not full course update rights) can still change syllabus_body through this same call, but every other field they pass is silently dropped rather than erroring. Use create_course for a new course, or get_course to see the current values before changing them.

Update an existing discussion topic in a course — title, message, published state, require_initial_post, delayed_post_at, or is_announcement — and return the updated topic; only the fields you pass are changed, the rest keep their current value. Course-scoped only: there is no update tool for group discussions, though list_group_discussions and get_group_discussion can still read them. Setting is_announcement: true asks Canvas to turn the topic into an announcement, but Canvas silently keeps it a plain discussion topic (HTTP 200, no error) if the caller lacks announcement-create permission in …

Update an existing module's name, position or published state, and return the updated module object. Only the fields you pass are changed — anything you omit keeps its current value. Setting `published: true` publishes the module AND every item inside it (items Canvas couldn't publish come back as `publish_warning_items`); `published: false` unpublishes the module and every item inside it the same way — there is no way to change a module's published state without it cascading to its items. Use `get_module` to check the current state first, and `list_modules` to find the module_id. Requires ins…

Edit an existing module item in place: rename it, repoint an ExternalUrl/ExternalTool item, reposition or re-indent it, publish/unpublish it, or move it to another module. ExternalUrl items exist only as module items, so a stale link carried in by a course copy can only be fixed here.

Update an existing New Quiz (LTI) in a Canvas course, found by its assignment_id (from list_assignments or get_assignment, filtered on is_quiz_lti_assignment, or from create_new_quiz — not a Classic Quiz ID). Only the fields you pass change; omitted fields keep their current value, so a repeated call with the same payload leaves the quiz unchanged. Pass null for due_at, unlock_at, or lock_at to clear that date. Returns the updated quiz (id, title, points_possible, due_at, unlock_at, lock_at, published, assignment_id). Use update_new_quiz_item to change an individual question instead of the qui…

Update an existing item (question) in a New Quiz (LTI). All fields are optional; supply only what changes. Canvas may rate-limit rapid sequential updates. Call serially (not in parallel). For >50 items, chunk and pause between batches.

Update an existing wiki page's title, body, published state or editing_roles. Only the fields you pass are sent to Canvas; omitted fields are left unchanged. body is not merged — it replaces the entire HTML body, so read the current content with get_page first and send back the full edited body, not just the changed part. Returns the updated page. Idempotent: calling it again with the same fields produces the same resulting page. Use create_page to make a new page instead, delete_page to remove this one, and update_course's syllabus_body parameter to edit the course syllabus, which is not a wi…

Upload a new file to a course's Files area from base64-encoded content, and return the created file object (id, display_name, size, content_type, download url). Each call performs a new upload; check list_files first if you want to avoid creating a duplicate, and use delete_file to remove a file afterward. Canvas handles the upload as a multi-step hand-off to its storage backend (S3 or local Canvas storage), transparent to the caller. `parent_folder_path` places the file in that folder, creating any missing folder segment along the way; see list_folders for what already exists. Requires permis…

Upload a file to the authenticated student's own submission area for one assignment, as step 1 of an online_upload submission (step 2: pass the returned file id to submit_assignment). Opt-in tool: only available when the server was started with CANVAS_ENABLE_ASSIGNMENT_SUBMISSION. Content must be base64-encoded. This uploads only — nothing is submitted until submit_assignment is called.

Interactive panel of active institution-wide announcements. Returns the same payload as `list_account_notifications` and additionally links to an MCP Apps UI resource that renders scannable announcement cards with type filters and search. Hosts that do not support MCP Apps fall back to the JSON payload (same as `list_account_notifications`).

Interactive tree view of a course's modules and items. Returns the same payload as `get_course_structure` and additionally links to an MCP Apps UI resource that renders an explorable tree with type filters and search. Hosts that do not support MCP Apps fall back to the JSON payload (same as `get_course_structure`).