Showing results for 
Search instead for 
Did you mean: 

Canvas Developers Group

Community Member

This is a general question about APIs. Imagine, we have an object (users, assignments, etc) in canvas with all parameters set especially (SIS ID, or integration ID). Now, I want to know, if I send an API(POST request) with exact parameters to canvas, what would happen when the object exists already in canvas?

The canvas ignore the POST request? or overwrite the object with the new request, or create a duplicate?

I am asking this question because I am developing a python code, reads the data from the database and sends POST requests to create an object in canvas, so I am worried if I send a request which the object is already into the system.


0 1 61
Community Participant

Exporting Canvas Live Events to your SQL database


7 6 490
Community Member


We are trying to set up Diffing mode to run our SIS files and are using the below CURL command.

/usr/bin/curl --tlsv1.2 -H 'Content-Type: application/octet-stream' -F diffing_data_set_identifier=DiffID -F attachment=@/home/batch/Canvas/ --output /dev/null --write-out '%{http_code}' --stderr /tmp/ -H "Authorization: Bearer TOKEN" 

Unfortunately the files are not updating anything in the system. Does anyone see anything wrong with our CURL command that may be causing this issue to occur?



0 0 48
Community Member

When submitting a multi HTML Content Items request, the generated HTML is wrong.

See how item #2 and #3 are embedded inside item #1 instead of after it:


Seems like a regression as it used to work fine a few days ago.

Any idea what is causing this?

Best Regards,


0 0 68
Community Contributor

I've created a Ruby script to add events to teacher and student personal calendars in our institution. This will post grading periods, holidays, and testing dates to allow for better planning by users.


2 0 156
Community Champion

Some time ago I wrote a program to compute an index for a course by walking the course pages and identifying key terms in the page, collecting all of the figure and table captions, all of the text that has been tagged as being in a language other than English, etc. and

see the heading "Making an index" at and details of using it can be found at 

The result is a wikipage with entries of the form:

<li>sockets API
<li><a href="../modules/items/316319">Socket API</a></li>

Note that the anchor HREF is to a relative location the "../" gets replace by the browser with the prefix for the page ( ) yielding the full URL 

I had to use these relative HREFs to reduce the index for the course down to 3 pages due to the limited size of wikipages. This works perfectly well for the student in the course.

If I run the link validator from the page that says:

Course Link Validator

The course link validator searches course content for invalid or unreachable links and images.
The link validator reports: Found 14,610 broken links
Nearly all of the claimed broken links do in fact work.

1 0 119
Community Champion

Making use of sections, grading standards, custom data columns, and other features of Canvas to support a course with ~600 students, ~180 examiners, lots of other teachers/TAs, etc.

Making administrative assignments to hold useful information - assignments to store and manage information concerning students (but not containing student submissions) - an alternative to custom gradebook columns.


0 0 99
Community Member

Hi! I'm Noah,
a student at the Karel de Grote Hogeschool in Antwerp who's studying NxTmedia Technology Web Development.

Since the COVID-19 virus changed the way of teaching and following lectures we've been trying to find a solution for the inactivity of students and for centralization of some information. Aftera long time of brainstorming we finnally found a "solution" that should make it possible for students an their teachers to get more attention for announcements that are being published on canvas.

In our school we use discord as a full time replacement of normal tutoring. since we had to do everything online to minimize the contact. Over a short period of time more and more students of were getting used to using discord as a teaching platform. Most of the students already knew Discord as a voice communication platform for gaming. Mostly they were online here instead of Canvas.

What we've created is a bot that makes it possible to create watchlists in text channels that announce new incoming announcements of the courses that are being watched.

This made it possible to reach our students much faster and created a much bigger chance for you that the students would read it.

we've just released the first version of our Discord bot and we would like some opinions! As honest as possible 😉

There is a more detailed explanation on our public GitHub repository for the ones who're interested! Also we've open-sourced the whole project just to support the community and help the ones who need it!

The link of our Open-source Discord Bot

6 6 1,962
Community Participant

As far as we can see, there is no built-in method to add and update user avatar photos in Canvas. Many organisations probably allow students to add their own avatars, but it's arguably better to have school photos in Canvas because teachers find them more useful to help with identifying students etc. This blog post describes a method which I have implemented to add all student and staff photos to Canvas, and to maintain them so that they revert to the 'official' photo if they are changed. Full code is available on GitHub. 


3 9 909
Community Champion

returns { 'notification_preferences': [ list ] } rather than [ list ]



0 0 172
Community Member

A script to generate a Postman collection based on Canvas' swagger documentation.


8 2 701
Community Participant

NEVER conclude courses!  We found this out the hard way.  It really creates more problems than it solves and concluding is pretty much the younger evil brother of the delete process.  You have been warned!


2 0 605

This blog post was authored by Xander Moffatt who is a Software Engineer on our Interoperability Team.

Safari blocks all 3rd-party cookies by default, which breaks LTI tools that rely on setting cookies when launched in an iframe. Instead, it exposes a new API for getting user-permitted access to set cookies from an iframe, which works though requires jumping through some fun hoops.


Safari has been working towards this step for a few years now, since the introduction of the Storage Access API and Intelligent Tracking Prevention. These features were introduced to limit cross-site tracking that users never agreed to, and to preserve their privacy. These limitations have also grown more strict over the years, with most third-party cookies already being blocked by the time of the newest release, 13.1.

Before this release, third-party cookies were allowed to be set once the domain has set a first-party cookie, which occurs when the tool is launched in the parent browser window instead of a child iframe. Canvas implemented this change to launch the tool in the parent window, let it set a cookie, and provide a redirect url so that the tool is launched again in an iframe, with the ability to set third-party cookies.

This release makes Safari the first mainstream browser to fully block third-party cookies by default, though Chrome aims to ship the same features by 2022. The Storage Access API should also be made standard, providing a known way for LTI tools to still be functional. Note that this behavior can be turned off, by disabling the Preferences > Privacy > Prevent cross-site tracking checkbox.

When this behavior is enabled, the current behavior of an LTI tool launch in Canvas is to get stuck in an infinite loop, since Storage Access hasn’t been granted and so the cookie can never be set.

Storage Access API

There are only two methods in the Storage Access API, but they are more complex than they look. document.hasStorageAccess asynchronously resolves to a boolean indicating whether the iframe already has access to set its own cookies. In practice, this is almost never true until a call to the next method, document.requestStorageAccess. This method also asynchronously resolves to a boolean indicating whether the iframe now has access. The hoops that require jumping through come with this method.

  • this method must be called upon a user gesture (like tap/click). this means the user must click a button and the listener for this button must directly call requestStorageAccess. any calls that aren’t inside a listener will immediately return false.
  • this method won’t return true for a domain in an iframe unless the user has interacted with the domain in a first-party context. This is to make sure that the user knows and trusts this domain. Interaction in this case means another user gesture like a tap or click.
  • this method will return true if the user has had storage access granted in the last 24 hours.
  • once this has been called from a user gesture, the user has interacted in a first-party context, and then the request is sent again from a third-party context, then Safari will prompt the user using a browser dialog box to allow storage access. Once the user clicks Allow, then this method will return true and the tool can finally set the cookies it needs to authenticate its user.


There are a couple of ways to approach this situation from a Canvas-launching-LTI tools standpoint, and both of them are on the tool side, as opposed to the Canvas side. Canvas continues its behavior of providing a redirect url when the tool requests a full window launch, but the tool has some decisions to make.

If your LTI tool can handle being stateless and not setting cookies (ie it doesn’t require logging in, or the login process is fast so can be done on every launch), do it. Move any non-login cookies to window.ENV or something, let the user login if needed, and just plan on that whole flow happening on every launch.

If your LTI tool requires storing state in cookies and keeping the user logged in, there is a slightly more complex process to work with an in-line Canvas launch. Note that the Storage Access API happens in Javascript, but most LTI tools want to set httpOnly cookies from the server for sensitive cookies like a login token, so once the tool has Storage Access, a final redirect back to the server to set cookies and render the UI will be needed.

  1. When the tool launches, use document.hasStorageAccess to check if the tool already has Storage Access. This will most likely never be true, but if it is, redirect to the tool server to set cookies and render the UI.
  2. Request Storage Access using a user button click that calls document.requestStorageAccess. If the user has granted Storage Access within the last 24 hours, this will be granted. If granted, redirect to the tool server to set cookies and render the UI.
  3. If the request fails, then it’s time to get user interaction in a first-party context. Send a postMessage to Canvas requesting a full window launch, providing the tool’s normal launch url.
  4. Once that custom postMessage has been sent, Canvas will launch the tool again, in a full window. Canvas will send a platform_redirect_url in the request parameters, which is how you can tell it’s a full window launch. Get user interaction by having them click a button, and on that click redirect to the url Canvas supplied.
  5. Canvas will redirect to that url, which means another tool launch in an iframe. The tool will go through steps 1 and 2 again, and this time Safari should prompt the user to grant access. Once that happens, the tool has Storage Access and should redirect to the tool server to set cookies and render the UI.

Efforts are being made to encapsulate this behavior in some sort of gem/module, but since it touches both server- and client-side code it might be hard.

Though this method requires anywhere from 1-3 user button clicks before the app loads, it does provide a non-hacky way of interacting with cookies in Safari.

note that these are snippets that don’t have all variables and dependencies added. They are just for reference!
  • checking for storage access
document.addEventListener("DOMContentLoaded", () => {
if (document.hasStorageAccess) {
.then((hasStorageAccess) => {
if (hasStorageAccess) {
.catch((err) => console.error(err));
} else {

<RequestStorageAccess />,
  • requesting storage access
const requestStorageAccess = () => {
.then(() => redirectToSetCookies())
.catch(() => requestFullWindowLaunch());

const buttonText = "Continue to LTI Tool";
const promptText =
"Safari requires your interaction with this tool inside Canvas to keep you logged in.\n" +
"A dialog may appear asking you to allow this tool to use cookies while browsing Canvas.\n" +
"For the best experience, click Allow.";

return (
  • requesting a full window launch
const requestFullWindowLaunch = () => {
messageType: "requestFullWindowLaunch",
  • interact with user in a first-party context
const SafariLaunch = () => {
const redirect = () => {
const buttonText = "Continue to LTI Tool";
const promptText =
"Safari requires your interaction with this tool outside of Canvas before continuing.";

return (

document.addEventListener("DOMContentLoaded", () => {
<SafariLaunch />,
  • handle different types of launches, including full window, Safari, and non-Safari
# Safari launch: Full-window launch, solely for first-party user interaction.
# Redirect to Canvas for inline relaunch.
if safari_redirect_required?
@platform_redirect_url = params[:platform_redirect_url]
return render('safari/full_window_launch')

if browser.safari?
# Safari launch: request Storage Access, then redirect to
# :relaunch_after_storage_access_request with pertinent cookie info
# If Storage Access request fails, request a full window launch instead.
@id_token = id_token
@state = state
return render('safari/request_storage_access')

# Non-Safari launch: set cookies and render app launch


7 2 2,625
Community Champion

After the fun yesterday of using the dashboard cards to make the entry of a course ID easier (Using the dashboard information via the API in programs ). I decided to do a similar thing for user IDs, so rather than have to enter a Canvas user_id for each program - why not be more flexible with a "person_id". The result is a program that can take any of several forms of user identification in and get a Canvas user-id for this user. It also shows how to use some of the SIS IDs at Object IDs, SIS IDs, and special IDs - Canvas LMS REST API Documentation.

    # check for numeric string, in which case this a Canvas user_id
if person_id.isdigit():
elif person_id.count('-') == 4: # a sis_integration_id
integration_id=person_id # since we have the ID, save it for later
elif person_id.find('@') > 1: # if an e-mail address/login ID
# assume it is a local university ID

# extract Canvas user-id from the user's info:
print("sortable name={}".format(info['sortable_name']))
print("Canvas user_id={}".format(user_id))

# try to get the user's integration_id via their profile
integration_id=user_profile.get('integration_id', None)
login_id=user_profile.get('login_id', None)
if login_id:


The routines user_info() and user_profile_info() just call the GET /api/v1/users/:id and GET /api/v1/users/:id/profile APIs respectively.

This has some relation to the question I ask in Searching for users and my several iterations of addressing the question.

Also, as noted in my reply to What is the use case for "integration_ids"? in order to get the user's integration_id, i.e., the sis_integration_id) - I had to use the GET /api/v1/courses/:course_id/enrollments API. I'm not completely sure why all of these different IDs for a user are not returned in the User structure returned by GET /api/v1/users/:id .

0 0 179
Community Champion

In most of my programs that use the Canvas API, I take in the course_id from the command line in numeric form (i.e., the string: 11). One of my colleagues said that he does not like to remember the course numbers but would rather use the course code or a nickname. So this motivated me to see if one could use the dashboard information for this.

The first thing I discovered was that it seems the dashboard API is not documented - or perhaps I just could not find it. So I watched a Canvas session in the browser and found the API is:

GET /api/v1/dashboard/dashboard_cards

So I made a test program to get all of my cards and make a spreadsheet of them, see at GitHub - gqmaguirejr/Canvas-tools: Some tools for use with the Canvas LMS. 

After looking at the cards and their information it was really easy to see how to use this information to make it so that you can convert the "course_id" that is actually a nickname, short name, or original name (or a prefix or substring of it).

def course_id_from_assetString(card):
global Verbose_Flag

if len(course_id) > 7:
if course_id.startswith('course_'):
course_id=course_id.replace('course_', "", 1)
if Verbose_Flag:
print("course_id_from_assetString:: course_id={}".format(course_id))
return course_id
print("Error missing assetString for card {}".format(card))
return None

# check if the course_id is all digits, matches course code, or matches a short_name
def process_course_id_from_commandLine(course_id):
if not course_id.isdigit():
for c in cards:
# look to see if the string is a course_code
if course_id == c['courseCode']:
# check for matched against shortName
if course_id == c['shortName']:
# look for the string at start of the shortName
if c['shortName'].startswith(course_id) > 0:
print("picked the course {} based on the starting match".format(c['shortName']))
# look for the substring in the shortName
if c['shortName'].find(course_id) > 0:
print("picked the course {} based on partial match".format(c['shortName']))

# check for matched against originalName
if course_id == c['originalName']:
# look for the string at start of the shortName
if c['originalName'].startswith(course_id) > 0:
print("picked the course {} based on the starting match".format(c['shortName']))
# look for the substring in the shortName
if c['originalName'].find(course_id) > 0:
print("picked the course {} based on partial match".format(c['shortName']))

print("processing course: {0} with course_id={1}".format(c['originalName'], course_id))
return course_id

Now, hopefully, there will be a happy user as in the main program to process the first argument of the command line as a course_id you simply say:

if not course_id:
print("Unable to recognize a course_id, course code, or short name for a course in {}".format(remainder[0]))

Of course, there are probably some gotchas - but it should work better than having to look up the numeric values.

1 1 290
Community Participant

You will require the following variables set up accordingly. Values such as $USERID, $COURSEID and $ASSIGNMENTID can be obtained from the API or looking at link URLs in the Canvas web interface.


>> $token = '<TOKEN>'
>> $headers = @{"Authorization"="Bearer "+$token}
>> $userId = 123
>> $asUserId = 456
>> $courseId = 789
>> $assignmentId = 101112
>> $fileName = 'submission.bmp'
>> $filePath = 'c:\submission.bmp'
>> $fileContentType = 'image/bmp' 


Step 1 - Initiate the assignment submission file upload process.

Note that the AS_USER_ID parameter is attached here to the URI to enable masquerading (otherwise you cannot upload a file to another user's account.)


>> $response = Invoke-RestMethod `
   -URI   "https://<HOST_NAME>:443/api/v1/courses/$courseId/assignments/$assignmentId/submissions/$userId/files?as_user_id=$asUserId" `
   -headers $headers `
   -method POST 


We obtain an upload URI from the $RESPONSE object.

>> $uploadUri = $response.upload_url


This upload URI has a life span of 30 minutes, and cannot be used after timeout. The response content contains a list of parameters called UPLOAD_PARAMS which should be included in the POST submission body along with the file data when the file is subsequently uploaded. For our school, these parameters are FILENAME and CONTENT_TYPE.


Step 2 - Construct a hashmap which includes the file to be uploaded, along with the file parameters specified in the response above. This hashmap is passed to the Invoke-RestMethod powershell command which sends the file as part of a form submission.

>> $form = @{

   filename = $fileName
   content_type = $fileContentType
   file = Get-Item -Path $filePath

>> $response = Invoke-RestMethod `
   -URI $uploadUri `
   -Method POST `
   -Form $form

>> Write-Host "$($response.size) bytes uploaded."




Step 3 - Associate the uploaded file with an assignment submission. The $RESPONSE object returned by the previous API call conveniently contains the ID of the file which was just uploaded. We create a $BODY hashmap which is then submitted as POST parameters to associate the assignment submission with the uploaded file. 


Note the braces "[]" which must be included after the "[file_ids]" parameter name.

>> $body = @{


>> $response = invoke-restmethod `
   -uri "https://<HOSTNAME>:443/api/v1/courses/$courseId/assignments/$assignmentId/submissions" `
   -headers $headers `
   -method POST `
   -body $body `
   -ContentType "multipart/form-data"


If no errors occur (these can be handled with TRY/CATCH) then the submission process has completed successfully. 

The $RESPONSE object returned by the previous call does contain values which might also be tested to determine if the submission has completed successfully (e.g. workflow_state='submitted') but I haven't yet encountered a scenario where a submission would fail without throwing a catchable error. 

1 0 313
Community Member

I've developed a tool I wanted to share here.  I teach multiple sections of a course with up to 72 students per section.  I typically merge all sections of my course into a single canvas site.  This works well for most things, but grouping 360 students into 60 teams manually is a nightmare.  The GUI for team management is an atrocious mess.

I've written a Google Apps Script in JavaScript that uses a Google Spreadsheet as the GUI.  With this tool, you can download your canvas roster, and then you can upload all teams automatically using another sheet.  

I wrote the tool to work with CATME team formation, specifically.  But, so long as the 'CATME Import' sheet contains the student email and team name, it should work fine for manual team formation.

This is my first stab at API coding, and so there are bound to be lots of errors and bugs.  For one, I don't have the OAuth2 worked out, so this version uses a temporary token that you get from your Canvas page.  

I've put a version of the code up on GitHub - GitHub - dagray3/canvas_api_scripts: collection of Google Apps Scripts in JavaScript for working wit... 

I don't know how to share the companion google sheet with others.  But, I think it's a good, rough beta that might be of use to someone.  Hit me up with a DM if you have questions or comments about the code.  Otherwise, be awesome.

2 2 468
Community Champion

In a Canvas course, you can quickly check the number of missing assignments for single students relatively quickly. You can also message groups of students missing specific assignments from the analytics page (or the gradebook). What you can't do is get a list of all students in a course and their missing assignments in a CSV for quick analysis.

In my never-ending exploration of the Canvas API, I've got a Python script that creates a missing assignments report for a course, broken down by section.


I have my own specific thoughts about using the "missing" flag to communicate with students about work. The bigger picture is that while we're distance learning, it's helpful to be able to get a birds-eye view of the entire course in terms of assignment submission. We also have enlisted building principals to help check in on progress and having this report available is helpful for their lookup purposes.

The Script

from canvasapi import Canvas # pip install canvasapi
import csv
import concurrent.futures
from functools import partial

KEY = '' # Your Canvas API key
URL = '' # Your Canvas API URL
COURSE = '' # Your course ID

canvas = Canvas(URL, KEY)
course = canvas.get_course(COURSE)
assignments = len(list(course.get_assignments()))
writer = csv.writer(open('report.csv', 'w'))

def main():
    sections = course.get_sections()

    writer.writerow(['Name', 'Building', 'Last Activity', 'Complete', 'Missing'])

    for section in sections:
        enrollments = section.get_enrollments(state="active", type="StudentEnrollment")
        # Play with the number of workers.
        with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
            data = []
            job = partial(process_user, section=section)

            results = [executor.submit(job, enrollment) for enrollment in enrollments]
            for f in concurrent.futures.as_completed(results):
                print(f'Processed {len(data)} in {len(list(enrollments))} at {section}')

def process_user(enrollment, section):
    missing = get_user_missing(section, enrollment.user['id'])
    return [ 
        len(missing), ', '.join(missing)

def get_user_missing(section, user_id):
    submissions = section.get_multiple_submissions(student_ids=[user_id], 
                                                   include=["assignment", "submission_history"], 

    missing_list = [item.assignment['name'] for item in submissions \
        if item.workflow_state == "unsubmitted" and item.excused is not True]

    return missing_list

if __name__ == "__main__":


How does it work?

The script uses UCF's canvasapi library to handle all of the endpoints. Make sure to pip install before you try to run the script. The Canvas object makes it easy to pass course and section references around for processing. Because each student has to be individually looked up, it uses multiple threads to speed up. There isn't much compute, just API calls and data wrangling, so multithreading worked better than multiprocessing.

For each section, the script calls for each students' submissions, looking for workflow_state="unsubmitted" specifically to handle filtering on the Canvas servers. From this filtered list, it creates a final list by checking the submission history and any excused flags. A list is then returned to the main worker and the section is written as a whole to keep the processes thread-safe.

When the script is finished, you'll have a CSV report on your filesystem (in the same directory as the script itself) that you can use.



Currently, missing assignments are joined as a single string in the final cell, so those could be broken out into individual columns. I found that the resulting sheet is nicer when the number of columns is consistent, but there could be some additional processing added to sort assignments by name to keep order similar.

Canvas is also implementing GraphQL endpoints so you can request specific bits of data. The REST endpoints are helpful, but you get a lot of data back. Cleaning up the number of bytes of return data will also help it run faster.

4 1 521
Community Champion

While schools are closed, we've moved much of our long term staff development material into Canvas. We have one long-running course with all staff split into site-based sections that has worked as a model for others. We needed a way to essentially duplicate the template course enrollments into new training courses.


Ignorance is bliss (sometimes) and I didn't know of a good way to make this happen. I looked at some of the provisioning reports, but I couldn't select a single course to run a report on. So, I reached for Python and the UCF Open canvasapi library to make it happen.


At the end of this process, I ended with a brand new course, populated with teachers enrolled in their specific sections. I was also able to disable the new registration email and set their course status to active by default.



from config import PROD_KEY, PROD_URL
from canvasapi import Canvas # pip install canvasapi

# Define your course IDs. Be careful!
template_course_id = ''
new_course_id = ''

canvas = Canvas(PROD_URL, PROD_KEY)

template_course = canvas.get_course(template_course_id)
new_course = canvas.get_course(new_course_id)

# Open the template course section by section
template_sections = template_course.get_sections()

# Get any sections that may already exist in the new course
new_sections = [ for section in new_course.get_sections()]

# This whole loop could be improved a little.
for section in template_sections:
    # Get all the section enrollments
    enrollments = section.get_enrollments()

    # If it's a brand new course, this should always be false
    if not in new_sections:
        print(f'Creating section {}')
        course_section = {
        new_section = new_course.create_course_section(course_section=course_section)
        count = 0 # start counting enrollments for quick quality checks
        for enrollment in enrollments:
            student = enrollment.user['id']
            print(f'Enrolling {enrollment.user["name"]}')
            count += 1
            args = {
                "notify": False,
                "enrollment_state": "active"
                new_course.enroll_user(student, "StudentEnrollment", enrollment=args)
            except Exception as e:
        print(f'Enrolled {count} users in {}')‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍


It's definitely brute force, but it saved us from having to copy and paste nearly 1,300 users into the new course by hand from a spreadsheet.


Why force enroll at all?

I think this highlights one of the barriers for really taking Canvas to the next level for staff support. There is no good way to enroll non-student users in courses for required development. In our case, it's to fulfill a required training for staff and using Canvas makes sense as a lot is done through application and reflection.


The public course index in Canvas could be used, but without a great way to expose the course to instructional staff only (I know we could use some JavaScript and edit the template, but that's just another thing to manage) it could lead to students joining courses either by accident or maliciously.


We've also toyed around with making a custom self-signup process on an internal website where staff are forwarded directly to the enroll page, but it's another system to manage and another site for teachers to use. The most hands-off approach for all involved is to do something like this in the background as needed to get people where they need to be effectively and efficiently.

5 4 891
Community Champion

So I thought I would try to make a ChatBot for Canvas to add to our staff EdTech Help canvas course.

I had come across a number of posts and ideas mentioning this a way back - this one in particular from  @sonya_corcoran  -  Microsoft's QnA Maker = Canvas FAQ ai  and also" modifiedtitle="true" title="AI chatbot which answers bas...

Spent a couple of hours trying to get it set up. Googled ChatBot. Got some advice about Azure and QnA Maker. Set up a free portal. Followed a few online help guides. Actually, it was not a difficult as I first thought..

Bit of trial and error, made a few mistakes along the way, struggled with some of the Tech but I've actually made one.

The Chat bot is embedded on a Canvas page. I used the Redirect tool used to create an entry on the Navigation menu to take you directly to the page.

Of course, this is the easy bit. The (fun part?) of the challenge is now to "program'' it and get it to be useful...


Just the start of a post. More to be added soon but please get in touch or ask questions below or share ideas and thoughts.....

Today's work (6th May)

Customising the standard Hello and Welcome! message to:


Thanks to - botframework - How to customize the "Hello and welcome" default response message in Microsoft Azure ... 

Customising the Default message - No QnA Maker answers were found to:


Thanks to - QnA Maker | How to customize the "No good match in FAQ" default response message - YouTube 

Adding some images:


Thanks to - How to Add Images to QnA Maker Answers in Markdown 

Learning how to use Markdown to add some formatting to your responses:


Thanks to - Markdown Tutorial - Introduction has a great hands-on tutorial!

Today's work (7th May)

There is an interesting option that allows you to import Word/PDF files to create Q&A responses. The format they suggest needs to be quite a formal design with the use of Headings for certain features eg


I tried this with a guide I had written for Learning Apps - the results were NOT GREAT! I had (secretly) hoped that I would magically create amazingly engaging FAQs with pictures and formats - nope. None of the pictures added and as such the step by step guide makes little sense.

To be fair, a little down the Microsoft Help guide - Import document format guidelines - QnA Maker - Azure Cognitive Services | Microsoft Docs it does suggest the sort of document that would work best (basically a Word based FAQ doc)


I have not tried this with the hyperlinks in place but if it does this then at least this is a step in the right direction..

Instead, I have been making use of the Markdown script to copy in links to Canvas pages in our EdTech platform:


My Help Guides are made in Word and I would ordinarily use the Office365 integration to link to this. Instead I PDF'ed the file and put it into the Canvas course.

What I am learning very quickly is how best to create a ChatBot flowchart that allows different approaches for users. Wonderfully enough, it has drawn me back to this superb blog post from  @Bobby2  Horse Before the Cart. Purpose first, Canvas second.‌ and wonderful comments from  @kmeeusen ‌

It is easier to create a chatbot that responds to a request by providing a link to a Help Guide and/or some examples.Of course the real challenge would be developing a framework not based on how you can get help but:

What would you like to be able to do?

Oh, before I forget, CanvasBot now has face to go with the name:


5 3 1,725
Community Champion

This post was originally published on my own blog.

In moving to online, we've tried to streamline all of our communication through Canvas. The goal is to cut down on disconnected email threads and encourage students to use submission comments to keep questions and feedback in context.

The Problem

Many students had already turned off email notifications for most communications in Canvas, preferring not to have any notices, which reduces their responsibility for teacher prompting and revision. Notifications are a user setting and the Canvas admin panel doesn't provide a way to define a default set of notification levels for users. However, with the API, we were able to write a Python program that sets notification prefs by combining the as_user_id query param as an admin that sets user notification preferences.

API Endpoints

  • GET user communication channel IDs: /api/v1/users/:user_id/communication_channels
  • PUT channel preferences for user: api/v1/users/self/communication_channels/{channel_id}/notification_preferences/{msg_type}


  • Int user_id
  • Int channel_id
  • String frequency

Get User IDs

There is no easy way to programmatically get user IDs at the account or subaccount levels without looping each course and pulling enrollments. Instead, we opted to pull a CSV of all enrollments using the Provisioning report through the Admin panel. We configured separate files using the current term as the filter. This CSV included teacher, student, and observer roles. The script limits the notification updates to student enrollments.

Script Details

The full program is available in a GitHub gist. Here is an annotated look at the core functions.

main handles the overall process in a multi-threaded context. We explicitly define a number of workers in the thread pool because the script would hang without a defined number. Five seemed to work consistently and ran 1500 records (a single subaccount) in about 7 minutes.

The CSV includes all enrollments for each student ID, so we created a set to isolate a unique list of student account IDs (lines 9-10).

To track progress, we wrapped the set in tqdm. This prints a status bar in the terminal while the process is running which shows the number of processed records out of the total length. This is not part of the standard library, so it needs to be installed from PyPI before you can import it.

def main():
Update Canvas user notification preferences as an admin.

unique = set()
data = []
with open('your.csv', 'r') as inp:
for row in csv.reader(inp):
if"student", row[4]):

with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
with tqdm(total=len(unique)) as progress:
futures = []
for student in unique:
future = executor.submit(process_student_id, student)
future.add_done_callback(lambda p: progress.update())

results = [future.result() for future in futures]‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

process_student_id is called by the context manager for each student ID in the set. Canvas breaks communication methods into "channels:" email, push, Twitter, etc (line 3). Each channel has a unique ID for each user, so we needed to call each user's communication channels and then pass the ID for emails to a setter function.

def process_student_id(student):
# Get their communication channel prefs
channel_id = get_channel_id(student)

# Update the channel prefs and return
update = update_prefs(student, channel_id)
return update
except Exception as e:

GET communication_channels

def get_channel_id(student_id):
url = f"{student_id}/communication_channels"
resp = requests.request("GET", url, headers=headers)

for channel in resp.json():
# find the ID of the email pref
if channel['type'] == 'email':
return channel['id']‍‍‍‍‍‍‍‍

PUT communication_channels/:channel_id/notification_preferences/:message_type[frequency]

The communication channel can receive several types of communications. We wanted to set the student notifications to "immediately" for new announcements, submission comments, and conversation messages. You can define others as well as their frequencies by modifying the values on lines 3-4.

The communication types are not well documented, so  we used our own channel preferences to find the notification strings: GET /users/self/communication_channels/:channel_id/notification_preferences.

The crux of this step is to make the request using the Masquerading query param available to the calling user. Make sure the account which generated the API key can masquerade or else the script will return an unauthorized error. 

def update_prefs(student_id, channel_id):
# loop through different announcement types
types = ["new_announcement", "submission_comment", "conversation_message"]
frequency = "immediately" # 'immediately', 'daily', 'weekly', 'never'
responses = []

for msg_type in types:
url = f"{channel_id}/notification_preferences/{msg_type}?as_user_id={student_id}&notification_preferences[frequency]={frequency}"
resp = requests.request("PUT", url, headers=headers)


return responses‍‍‍‍‍‍‍‍‍‍‍‍‍

Final Thoughts

Updating a user's personal preferences isn't something I was thrilled about doing, but given our current circumstances, it was preferable to the alternative of continuing to struggle to help students move forward in their coursework. Further improvements would be to call each CSV in the file system incrementally, cutting down on the time someone has to log in and run the script. Hopefully, this only needs to be done once and does not become a recurring task. Second, there is an endpoint in the API to update multiple communication preferences at once, but it isn't well documented and I wasn't able to get it working reliably. For just one channel and three specific types of messages, the performance improvements probably would have been negligible (at least that's what I'm telling myself).

5 1 533
Community Member

Hello Smiley Happy  

I have started to design ready-made canvas design templates for courses. This project I have started as an Open-Source code under MIT (which means free). and anyone can use this. I would love to hear your feedback/suggestions.

The cool thing about this project is Zero Dependency - (No need to include any and CSS or js files into your canvas instance)


My Github Project: Click Here - CanvasLMSDesigns

Don't forget to check the demo Smiley Happy 



  • Zero Dependency - (No need to include any and CSS or js files into your canvas instance)
  • Compatible with Canvas LMS editor

How to use

  • Go to this file - Design-1/index.html - Click here
  • Copy index.html HTML codes
  • Paste into the Canvas LMS editor



This is my first design

4 0 1,380
Community Champion

To follow up on my earlier question in Generating an index and permitted attributes for &lt;span&gt; this blog post contains some more information about generating an index from the pages in a Canvas course. A full description, script, and source code can be found under "Making an index" at GitHub - gqmaguirejr/Canvas-tools: Some tools for use with the Canvas LMS. 

Basically the process is based on creating in a local directory a copy of all of the HTML pages in a Canvas course along with some metadata about the module items in the course. Once you have the files, you can find keywords and phrases from the HTML and then construct the index or in my case a number of different indexes. I have split the process of finding keywords and phrases into two parts, the first works on the HTML files to find the strings in the various tags and stores this into a JSON formatted file - and the second part is part of the program computes the indexes. In this second program I started by splitting the text into words with a simple regular expression and then switched to using the Python NLTK package - specifically, the functions nltk.sent_tokenize(string1) nltk.word_tokenize(string2).

The resulting page (computed from ~850 HTML files) can be seen at Test page 3: Chip sandbox 

With regard to <span>, I found it useful to use them in three ways:

1. To keep a set of words together as a logical "word":

<span>Adam Smith</span> <span>Autonomous system number</span>

2. To mark text that I did not want to index:

<span class="dont-index">20% error rate</span>

3. To mark text as a reference (that I do not want to index):

<span class="inline-ref">(see Smith, Figure 10, on page 99.)</span>

Overall, the process of generating an index was useful - as I found mis-spellings, inconsistent use of various terms and capitalization, random characters that seemed to have been typos or poor alternative img descriptions, ...). It also was a nice forcing function to rework some of the content.

However, it remains a work in progress. I know that there are a number of weaknesses, such as not being careful in the final index to language tag entries and there is a need to remove some additional words that probably should not be in the index. Also, this is not a general-purpose natural language processing program - it could make better use of the NLTK package and it is very English language centric (in that it assumes the default language of the course is English, it does not pass the actual language information to the tokenization function, and it only contains stop words in English).

0 0 169
Community Team
Community Team

Canvas product management wants to collaborate with you regarding future Canvas improvements!

If you are interested in being notified about opportunities for feedback, please follow this document via the Actions menu. Following this document will notify you when this document is updated with a new feedback opportunity.

To learn how to follow this document, please see How do I follow people, places, or content in the Canvas Community?

Available Feedback Opportunities

Feedback links will be removed when no longer available. Most surveys will remain posted for approximately one month.

Posted 2 March 2020

Survey: User Online Interactions Research

Purpose: To build a comprehensive list of student online interactions that can be tracked and reported using Canvas.

Questions: How does your institution define student online interactions? What data points are you collecting to report on those interactions?

5 0 1,010
Community Participant

This blog describes how to move user enrollments from one role to another using a Python class, SQL data, and a mapping file.

So here is the situation we are presently facing at Everett Public Schools.  Along with our base roles of Student, Teacher, Designer, etc., we also have custom roles that have been derived from those base roles.  These custom roles are a bit more refined and help keep users and there permissions in check.  The problem with this idea is that not everyone follows the rules when assigning a role to a user when that user is enrolled into a course.  This quickly becomes an issue when trying to search and sort users based upon their permissions.

Case in point: We have teachers that are enrolled as students in staff courses or portals that are located at their respective school or sub-account.  So are they truly a student in the classic sense?  No.  When you do a blind search for students, you get back a bunch of teachers and maybe a few other users that somebody down the line added to a course as a student.  Now that the user data set has gotten out of hand, how do you move those enrollments over to the new custom role that you just created?  In addition to that, how do you keep it all in sync?

The solution comes in a few simple steps which you can follow below.  First, you need to decide what data set of users need to be moved from one role to another?  In our case, we wanted non-students (i.e. district staff) that were currently assigned the base role of StudentEnrollment (aka Student).  These district IDs are the same as their login id and SIS id too, so it keeps things straight.  Since we run multiple nightly integrations, we simply just created a new section in our SQL code to only pull the district staff IDs.  Like this:

IF @type = 'STAFF_USERS'
SELECT login_id
FROM eps_canvas.dbo.users
WHERE user_type = 'F';

Just a bit of a backstory to explain the logic.  In Everett we use several nightly imports into Canvas to roster courses, control users, etc.  More on that in another blog, but to suffice it to say it works very well.  We use a 'users' table in a smaller database to control who gets put into Canvas.  The user_type of 'F' is for 'faculty'.  So when this script runs, it uses the 'staff_users' input parameter to control what data set the script will receive.  This logic comes from the script configuration .ini file:


#API SIS upload URL for the site
#Root account should always be 1

#The URL string data that allows acting as another user
#The 'replace' placeholder gets replaced with the correct term in the script
masqueradeData: {"as_user_id": "replace"}

#The list of parameters to pull from the DB
#Use this list to effect the role mappping below
#Comma delimited, any order
dbParams: staff_users

#Text of the SQL Server stored procedure SQL
#For getting of district ids
dbSQL: exec eps_internal.dbo.pyCurGetCanvasCustomExtracts ?

#The endpoint to get enrollments for a user
enrollmentsEndpoint: users/self/enrollments

#The endpoint to enroll the user in the course
coursesEndpoint: courses/{}/enrollments

#The endpoint to get all of the current roles
rolesEndpoint: accounts/1/roles

#The mapping from one role to another for each DB parameter
#The key for each map is keyed off of the dbParams list
#The JSON object for each dbParam is a key of the permission type to find, the value is the role to assign
#All values are case sensitive and must match exactly to what is in Canvas
roleMapping: {"staff_users": {"StudentEnrollment": "Adult Learner"}}

When the script is executed, it looks for an associated configuration file and reads in the [Default] section data.  It does read a master configuration file too so it can set some global variables, but that is outside the scope of this post.  Each parameter is then assigned to an internal variable that the script uses to do its thing.  Jumping down to the bottom line in the file, the roleMapping dictionary is keyed to the dbParams value.  This is how the data set knows what users to process, what role to look for (in this case 'StudentEnrollment') and what role to use when enrolling the user into the current course ('Adult Learner').  If we wanted to process more users this this script workflow, then we add a value to the dbParams list and add the same value to the roleMapping dictionary along with the roles to use.  

At some point, we needed to create our 'Adult Learner' role.  We wanted a role that was student based but that could be used for staff members that are fulfilling some student role in a course somewhere.  We wanted the student role to truly reflect actual students in the district.

So now we are ready to roll.  Consider this Python class:

from requests import Session
from classEpsDB import EpsDB
from classEpsException import EpsException
from classEpsConfiguration import EpsConfiguration
from json import loads
from urllib import parse

class EpsITSyncCanvasEnrollments(object😞
Syncs the Canvas enrollments between what was assigned to a user and what should be the correct assignment.
We do this to keep users from getting the incorrect enrollment and streamlining the search process.
@package: epsIT
@copyright: 2020, Everett Public Schools
@author: DPassey
@version: 1.0, 02.24.2020

def __init__(self, user_id_type='sis_user_id'😞
Class initializer.
Parses the config file_name, assigning values as needed.
@raise exception: EpsException
cfg = EpsConfiguration(f"{self.__class__.__name__}.ini")
self.rc = 0
if not cfg.db_dsn: raise Exception(f"{self.__class__.__name__}.__init__. DSN data source is missing.")
for k in cfg.locals:
k = k.upper().strip()
v = cfg.locals[k].strip()
if k == 'DBSQL': db_sql = v
if k == 'DBPARAMS': param_list = v.split(',')
if k == 'ROOTURL': root_url = v
if k == 'MASQUERADEDATA': masquerade = v
if k == 'ENROLLMENTSENDPOINT': enroll_endpoint = v
if k == 'COURSESENDPOINT': course_endpoint = v
if k == 'ROLEMAPPING': roles_map = loads(v)
if k == 'ROLESENDPOINT': roles_endpoint = v

# set the session header
self.header = {'Authorization': f'Bearer {cfg.canvas_token}'}

# must be one of these
if user_id_type not in ('sis_user_id', 'sis_login_id'😞 raise Exception(f'{self.__class__.__name__}.__init__. Invalid parameter: {user_id_type}.')

# create a session
with Session() as self.session:
# get the type of user from the parameter list
for _ in param_list:
# get all of the active roles
url = f"{root_url}{roles_endpoint}"
# for each mapped role for this parameter, get the role's id
roles_dict = self.get_account_roles(url, roles_map[_])
# get the data to process for each parameter
data = self.get_data(cfg.db_dsn, db_sql, _)
# proceed if we get user data
if data:
# for each user in the data, find the applicable enrollments to move
for user in data:
# set up masquerading
self.data_dict = loads(masquerade.replace('replace', "{}:{}".format(user_id_type, user[0])))
# get all of the user's enrollments to see if we need to change enrollments
user_dict = self.get_enrollments(f"{root_url}{enroll_endpoint}", roles_map[_])
# now process the users by their Canvas id
for user_id in user_dict:
# process each course and re-enroll the user
# we need to keep the indexing linked between course and enrollment
for c, course in enumerate(user_dict[user_id]['courses']):
# get the role id of the new role
# need this to move enrollments
role_id = roles_dict[user_dict[user_id]['roles'][c]]
# get the current enrollment id
enroll_id = user_dict[user_id]['enrollments'][c]
endpoint = course_endpoint.format(course)
# now set the new enrollments
self.set_enrollment(f"{root_url}{endpoint}", user_id, role_id, enroll_id)

def get_data(self, dsn, sql, param):
Executes the stored procedure and gets the applicable data set.
@param dsn: String
@param sql: String
@param param: String
@return: List
@raise exception: EpsException
db = EpsDB(dsn)
if not db: raise Exception(f"{self.__class__.__name__}.get_data. Could not connect to database.")
rs = db.get(sql, param)
if not rs: raise Exception(f"{self.__class__.__name__}.get_data. No data set returned.")
return rs

def get_account_roles(self, url, role_dict):
Gets the active roles and puts them in a roles dictionary.
@param url: String
@param role_dict: Dictionary
@return Dictionary
@raise exception: EpsException
role_id_dict = {}
# get all active roles
data_dict = {'state[]': 'active', 'per_page': 100}
resp = self.session.get(url, data=data_dict, headers=self.header)
if resp.status_code == 200:
# check the headers "link" attribute for the last relational link
for link in resp.headers['Link'].split(','😞
if 'rel=last' in link.replace('"','').replace("'",'').lower():
# grab the total pages count by parsing out the url parts and convert to int
page_total = int(parse.parse_qs(parse.urlparse(link.split(';')[0])[4])['page'][0])
# we need to get all results since we are being paginated
# these sections perform the same logic, just easier to to write it this way
if page_total > 1:
p = 1
while p <= page_total:
data_dict.update({'page': p})
resp = self.session.get(url, data=data_dict, headers=self.header)
json = loads(resp.text)
for _ in json:
if _['role'] in role_dict.values(): role_id_dict[_['role']] = _['id']
p += 1
json = loads(resp.text)
for _ in json:
if _['role'] in role_dict.values(): role_id_dict[_['role']] = _['id']
else: raise Exception(f"{self.__class__.__name__}.get_account_roles. Response {resp.text} returned.")
return role_id_dict

def get_enrollments(self, url, map_dict):
Gets the roles for the user and place in a user dictionary.
@param url: String
@param map_dict: Dictionary
@return Dictionary
@raise exception: EpsException
user_list = []
enrollments_list = []
roles_list = []
user_dict = {}
# make a copy of the class data dictionary so we can update it
data_dict = self.data_dict.copy()
# we should never exceed the per_page value
# i mean really....over 100 enrollments?
# current_and_future is a special state for all courses, published and unpublished
data_dict.update({'state[]': 'current_and_future', 'per_page': 100})
resp = self.session.get(url, data=data_dict, headers=self.header)
if resp.status_code == 200:
json = loads(resp.text)
for _ in json:
# check if user is enrolled in the course per the map_dict keys
if _['role'] in map_dict:
user_id, course_id, enroll_id = [_['user_id'], _['course_id'], _['id']]
# build the user enrollment dictionary for those mapped roles
if user_list: user_dict = {user_id: {"courses": user_list, "enrollments": enrollments_list, "roles": roles_list}}
else: raise Exception(f"{self.__class__.__name__}.get_enrollments. Response {resp.text} returned.")
return user_dict

def set_enrollment(self, url, user_id, role_id, enroll_id):
Sets the user enrollment for the course by deleting the original enrollment, making a new one.
@param url: String
@param user_id: Int
@param role_id: Int
@param enroll_id: Int
@raise exception: EpsException
# now we enroll the user in the proper role
# we keep the enrollment type blank so the role id will override the base enrollment
data = {"enrollment[user_id]": user_id, "enrollment[type]": '', "enrollment[role_id]": role_id, "enrollment[enrollment_state]": "active"}
resp =, data=data, headers=self.header)
if resp.status_code == 200:
# do not change the url as we want to delete the old enrollment now
resp = self.session.delete(f"{url}/{enroll_id}", data={"task": "delete"}, headers=self.header)
if resp.status_code == 200: self.rc += 1
else: raise Exception(f"{self.__class__.__name__}.set_enrollment. Response {resp.text} returned.")
else: raise Exception(f"{self.__class__.__name__}.set_enrollment. Response {resp.text} returned.")

# end of class
x = EpsITSyncCanvasEnrollments()

This is the flow:

  1. Read in the configuration .ini files, one that is global (the EpsConfiguration class) and one that named the same as this class
  2. Assign the configuration values to class values
  3. Query the database for the data set of user login ids
  4. Get a data set of all of the roles that currently exists in our Canvas instance
  5. For each user, act as that user and get all of the current and future enrollments
  6. Using the mapping dictionary, find each enrollment that we need to change and get the role id value from the list of roles that were grabbed earlier
  7. For each enrollment that is applicable for the user, enroll the user in the new role for the course and set it to active and then delete the old enrollment

And there you go.  You have moved all of your applicable enrollments over to the new one without having to do it manually.  Setting this script up as a regular job, depending on your needs of course, will ensure that your Canvas user role assignments don't get out of control.

3 1 472
Community Champion

I find the current system of emails of newly submitted assignments to be almost worthless, as I am in a number of courses where there are large numbers of students and most of them are irrelevant from my point of view as a teacher. In these courses, sections have been created to make it easy for a teacher to view the subset of students that is actually relevant to the teacher. However, since I have a large number of such courses (i.e., more than a dozen) and students are submitting material at their own pace through these courses, it is difficult to find the wheat among the chaff of notices about submissions for each of these courses.

This motivated the design of a program to get information about just the assignment submissions that I am interested in. Of course one can easily get a list of all the courses that a user is in, but how can you know what sections within these courses a user is interested in?  The answer is to ask the user to provide this information!

The result is two programs:


The first program creates a JSON formatted file with a course_info dictionary of the form:

{"courses_to_ignore": dict_of_courses_to_ignore,

"courses_without_specific_sections": dict_of_courses_without_specific_sections,

"courses_with_sections": dict_of_courses_with_sections


courses_to_ignore are courses that the user wants to ignore
courses_without_specific_sections are courses where the user is responsible for all the students in the course
courses_with_sections are courses where the user has a specific section - the specific section's name may be the user's name (in Canvas) or some other unique string (such as "Chip's section"). Because the name of the relevant section can be arbitrary, this file is necessary to know which section belongs to a given user.

The second program reads the information from the JSON file and then prunes out the courses_to_ignore from the list of a user's courses and then uses the information from courses_without_specific_sections and courses_with_sections to iterate through the courses and looks for ungraded assignments and then for each of the relevant students (in a course or section) looks for an ungraded assignment. Currently, the program just outputs information about these assignments.

To set up the JSON file is easy, you simply run the first program and then move entries from the courses_with_sections dict to one of the other dicts (removing unnecessary or irrelevant sections as you go). You can fun the first program in update mode (with the -U flag) to add more courses - it remembers the courses you have set to be ignored and the ones you have responsibility for all the students.

The programs can be found at GitHub - gqmaguirejr/Canvas-tools: Some tools for use with the Canvas LMS. 

Of course, I discovered an assignment that had been submitted that I had not seen, so on to grading it!

2 0 236

tl;dr tools that utilize cookies and integrate with Canvas will need to add SameSite=None and Secure attributes to their cookies to maintain current behavior.

Last year Chrome announced they'll be implementing a new cookie model in an upcoming version of Chrome (scheduled to release in February). Additionally Mozilla (Firefox) and Microsoft have announced their intention to support the new model as well. We've heard a few questions recently about how this update will impact Canvas so I'll answer a few of the most pressing questions below and provide a few additional resources.

Q: What changes does Canvas need to make?

A: Canvas itself doesn't need to make any updates. However, Instructure does maintain a number of LTI tools that integrate with Canvas. Some of these tools may need to be updated and we have been working internally to ensure these updates are made.

Q: As an LMS admin do I need to update anything?

A: There's no need to update anything in Canvas. But if your institution has developed an LTI tool or maintains an LTI tool your development team may need to make some changes. Additionally you'll want to verify any 3rd party tools you use have made the appropriate changes as well.

Q: I maintain an LTI tool that utilizes cookies, what do I need to do to make sure my LTI tool works the same after Chrome v80 releases?

A: You'll need to add a couple of attributes to each cookie. The first attribute SameSite=None will maintain the same behavior and the secure attribute is required when setting the SameSite attribute.

Q: How can I make sure we won't have any issues before Chrome v80 is released?

A: Make sure you have updated to Chrome 77+. You can open your Chrome developer tools and navigate to the Console tab. Once this tab is open click on your LTI tool(s) in the browser and look for a warning that begins with "A cookie associated with a cross-site resource ...". This warning will also provide a URL which should help you track down who needs to begin making updates.

Q: Where can I find more information?

7 11 7,044
Community Champion

In this post I'm compiling a list of feature ideas that relate the new quiz tool so I can keep track of them. I want to thank everyone who created a feature idea about the new quiz tool. This has been very helpful for me. I want to get each person credit for the feature idea posted.  I apologize if you receive multiple notifications about this blog post. I am hoping that this list helps to bring these issues to surface so more people can discuss why these feature ideas are important. Currently, new quizzes is a feature option in the course settings. If you don't see new quizzes in the list of feature options in the course settings, then your institution has not made it available yet. View the following resources to learn more about new quizzes. 

  • New Quizzes Group - This group includes timeline information and additional information about new quizzes. 
  • New Quizzes Guides - The guides help you learn how to create quizzes and migrate content. 
  • New Quiz Migration Options - I created this post because there are a couple of different ways you can migrate quizzes and there are pros and cons to each way. Also, choosing a migration option is dependent on how you use the current quiz tool. 

So here is the list. I decided not to included feature ideas that have been marked completed. You can see a list of completed feature ideas from the Idea page in the Canvas Community. As ideas below get completed, I will mark them in the list below. I know I didn't get all of them so please post feature ideas in the comments and I will add them to the list.   

Feature Ideas about Integration with Canvas Interface

There were several in this list that I was not aware of that I find troublesome. For me currently, the module back and next buttons are much needed. Many of our faculty like to use requirements and prerequisites and when students land on a new quiz page, this breaks the flow for students moving to the next item in the module. 

Permissions in New Quiz Tool

I am glad to see the item bank sharing option now available but I don't like that all people who have been given access to the item bank have the same read/write access. I am hoping that permissions with item bank sharing can become more granular. 

Feature Ideas about Question Types and Creating Questions

There are lots of great feature ideas listed below. I love creativity of all the ideas. One area of new quizzes that Instructure folks have been pretty quiet about is surveys. I would love to know more about what will be available for surveys. Hint! Hint!

One thing I do want to point out is that the rich content editor in the new quiz tool is not the same as the as rich content editor that is currently available in the production instance of Canvas. It is also important to note that there is a new rich content editor that is available in beta. I hoping that when the new editor becomes available in production that there will be consistency across all tools. You can learn more about the new rich content editor at the link below. 

New Question Types

Editing Questions

Multiple Choice Question Type

Matching Question Type

Formula Question Type

Numerical Question Type

Hot Spot Question Type

Essay Question Type

Fill-In-Blank Question Type

File Upload Question Type

Outcomes and New Quizzes

Questions and Item Banks

It seems organization tools are lacking in the new quiz tool. I feel organizational features are super critical for faculty because it saves them time. Time is precious when you teach.  

Feature Ideas about Quiz Settings

The quiz settings have come a long way in the past year. There have been many releases that affect quiz settings but I feel it still needs to tweaked a bit more. 

Student Experience Taking Quizzes

We only have a handful of teachers who are using the new quiz tool and so far no student complaints. 

Moderation and Grading

Overall the new moderation options are nice and I like that the moderation options are with the quiz settings now. I feel the time moderation options are bit more confusing. Now there are two different places to adjust time for students. For some reason I missed this when it was released. It does offer more features so that is good. See the June 22, 2019 release notes.  

Feature Ideas about Quiz Analysis and Reports

It just needs to function at least as good as the current quiz tool analytics. I have one instructor who wants to be able to see which students missed an item and he can't in the new quiz tool. He also misses the download option. 

9 2 971
Community Champion

In this blog post I will document the different ways I have found that you can migrate quiz content to the new quiz tool. I want to document what my experience has been and the issues or concerns I've found. Currently, at our institution we only have a few instructors using the new quiz tool, I don't have much experience with issues past migration. This post is based on my testing of the migration options. I am interested in hearing about any tricks or nuances others have found, so please share them in the comments below. I am finding this process very overwhelming especially in helping faculty make the right choices for their own content. This is a long post so here goes. 

Enable the New Quiz Tool

If you have not enabled the new quiz tool in a course, you can do this in the Feature Option section of the course settings. Once enabled, you can create quizzes in the new quiz tool from the assignment index page. See the following guide for details. 

Important Notes

Please note the following:

  • If you do not see the new quiz tool option in course feature options section, it must be enabled at the admin level. Contact your local IT support for assistance.
  • It is important to note that when people create quizzes in the new quiz tool, on the assignment and module pages, the icon next to the quiz will be the assignment icon and not the rocket icon. This can be confusing for faculty. I recommend that people add the word "quiz" to the title of any quiz they create in the new quiz tool. 

Preparation in the Current Quiz Tool

Preparation is critically important to consider so you don't lose any content you want to keep. Review how your quizzes are setup in the current quiz tool to determine which migration option is best for your quiz content and your current workflows using the current quiz tool. It is important to note that some question types listed below will have issues with the migration process. 

Questions to Consider

Below are some questions to ask yourself about the content you are migrating. 

How have questions been created in the current quiz tool?

If you have imported content from Respondus or textbook publishers, you will typically have a quiz and question bank created for each import in the current quiz tool.

If you have created questions directly in quizzes, then it is important to understand that all of the questions will exist in your quizzes and in a question bank called "unfiled questions". The questions in the question banks are considered copies. In the current quiz tool, if you update the question in the quiz, you must also update the same question in the question bank. There is no connection to the questions in the quiz to same questions in the question banks This may be important to consider if you have some content that only exists in the question banks. If you are not sure what content you have in the question banks, it is a good idea to review the question bank content and organize as desired. You may need to create new quiz and use the Find Questions option to add questions from question banks to the quiz so question banks content can be migrated. It is also important to note that in current quiz tool, question banks are tied to the course.  

Important Notes

In the new quiz tool the quiz/item bank relationship is the exact opposite of the current quiz tool. When questions added to the quiz from item banks, the questions are linked to the quiz and must be edited in the item bank. Additionally, item banks in the new quiz tool are tied to the person who imports the content. Item banks can be shared with other people; however, all people who are added to the item bank will have the same read/write privileges. It is important to understand these differences. 

How are quizzes setup in the current quiz tool?

The answer to this question is very important information to know because some of the migration options don't work with quizzes that use question groups. If questions have been added directly to the quiz, then all migration options listed below will work. Review the migration limitations with quizzes using question groups. 

  • Linked question banks in question groupsQuizzes that use question groups with linked banks will NOT import! If your quizzes are setup this way, then you must delete the linked question group and add the same questions directly to quiz using the Find Questions option. This is where answers to the first question above becomes critical to know so you can locate the desired questions in the question banks. 
  • Question Groups with questions added directly to the question group - The questions in the question groups will migrate using option 1 and 2 below but WILL NOT migrate using option 3 listed below. If you wish to use option 3 as the preferred migration option, then you must edit the quizzes and move all questions out of the question groups so the questions will migrate. This will be tedious process if you have many quizzes. It may be better to use option 1 or 2 as the migration process. 

Once you have finished reviewing your content in current quiz tool, you can chose the migration option that works best for you. Be sure to review the pros and cons of each option so you understand where you will be spending your time in the migration process. Time is precious so use it wisely. 


Option 1: Export as a Quiz/Import as Item Bank

In this option you must export each quiz from the course individually and then import each exported QTI file directly to a new item bank in the new quiz tool. This option requires the most steps to complete, but this process can save you time in the new quiz tool. 

Pros of this option

Cons of this option

  • This option will require you to recreate your quizzes in the new quiz tool since questions are imported directly to item banks. 

Step 1: Export Each Quiz from the Current Quiz Tool

Each quiz in the current quiz tool must be exported as QTI file. See the following guide for directions on how to do this.  

Important Notes

Be sure to review the numbered items for each step in the export process.  (1) On the export screen be sure to check quizzes.  (2) Next to All Quizzes, be sure to uncheck this box and select the box next to the desired quiz to export. (3) Click Create Export. (4) The QTI package will be linked above the export options. Click the link to download the file. It is important to note that each export file will be named with the name of the course only. You may want to change your browser settings (see links below) so you choose the location where you want to the save the file. This will allow you to include the quiz name in the export file name as you are saving it.  You can continue this process until you have exported all quizzes. 

Export Screen in Canvas

How to Change Browser Settings for File Downloads

Review the following guides for details. 

Step 2: Create a New Quiz or Access an Existing Quiz in the New Quiz Tool

Once you have exported your content, you can import each QTI file directly in the Item Bank section of the new quiz tool. You can access item banks from any quiz in the new quiz tool so it does not matter if it is a new or existing quiz. Go to the assignment page and create a quiz in the new quiz tool or click the title of existing quiz in the new quiz tool. 

Step 2: Import Exported QTI File in New Quiz Item Bank

Once you access quiz build tab, click the options menu ( 3 dots) in upper right corner of the screen and select Manage Item Banks. Click the +Bank option to create a new bank. Click the title of the new bank and click the item bank options menu (3 dots) and select Import Content. Follow the guide below for instructions. 

Important Notes

You can access any quiz in the new quiz tool to import an item bank. In the new quiz tool item banks are tied to the person who imports them so you will see all item banks you have ever imported regardless of which course you are working with at the time. It is also important to note that only one QTI file per item bank can be imported so you will need to create a new item bank for each imported QTI file. Once the import is complete the name of the item bank will change to the quiz name from quiz name from the imported file from current quiz tool. If you teach multiple courses, you may want to edit the title of an item bank to include the course name. That way you can distinguish a chapter 2 item bank from English course from chapter 2 item bank from literature course. 


Option 2: Export a Quiz/Import as Quiz

In this option you must export each quiz from the course individually (same process as option 1) and then import each QTI export file into a new quiz in the new quiz tool.

Pros of this option

  • If questions were added directly to a quiz in the current quiz tool, the imported questions can be edited directly in the quiz.
  • If questions were added to question group in a quiz in the current quiz tool, questions will import as randomized set and an item bank is created for each question group that was in the quiz in the current quiz tool. Questions will need to edited in the item bank.   

Cons of this option

  • If questions were added directly to a quiz in the current quiz tool, this option does not create a corresponding item bank. 
  • If you wish to add questions to item bank, each question must be edited to add the question to item bank. There is no bulk add option. See the following guide. 

Step 1:Export Each Quiz from the Current Quiz Tool

This is exact same process as Option 1, Step 1 from above. 

Step 2: Create a New Quiz in the New Quiz Tool

Go to the assignment page and create a new quiz. Important Note: You can only import a QTI file in new quiz that has no content. 

Step 3: Import QTI File in the New Quiz

In the new quiz tool click the option menu ( 3 dots) in upper right corner of the screen and select Import Content. Follow the guide for instructions. 


Option 3: Migrate from the Quiz Page

This option is the easiest to complete; however, there are several disadvantages to using this option. Review the pros and cons below. 

Pros of this option

  • One click migration
  • Questions can be edited directly in the quiz

Cons of this option

  • If quizzes in the current quiz tool are setup in question groups, the quiz content will not migrate. 
  • This option does not create a corresponding item bank.
  • If you wish to add questions to item bank, each question must be edited and item bank option must be selected. There is no bulk add option. See the following guide. 
  • You cannot randomizing large pool of questions until all questions are added item banks. Then questions must be added to the quiz as randomized set. If using randomized sets are important to you, it is recommended to use option 1 migration path instead. 

Step 1: Migrate the Quiz from Quiz Index Page

This option only includes one step. Go to the quiz page and select the options menu next to the quiz. In the option menu, select Migrate. The quiz will display on the assignment page in assignment group called migrated quizzes. See the following guide. 


Additional Resources

Below are some Canvas Community resources about the new quiz tool. 

12 10 2,388
Community Champion

At InstructureCon2019 the new rich content editor was unveiled so I decided it was time for update to the Rich Content Editor HTML Cheatsheet (see the original post). It important to note at this time the new editor is course level feature option and must be enabled in a course. Instructure plans to enable this option for ALL courses in the July 2020 update. See Upcoming Canvas Changes for details. 

Update 5/5/2020

The new rich content editor will NOT be enforced in the July 2020 update. See the following blog post for more details. 

Update 1/2/2020

The rich content editor was included in the October and November 2019 release notes but was removed based on feedback. The rich content editor was added to the January 2020 release. Be sure to review the release notes at the links below. The new rich content editor is available in beta. It is stated in the release notes that the end of life of the current editor will be in the July 2020 update


Below is an image of the toolbar highlighted with numbers of each command. In this blog post each numbered command has a code example with some tips on using in the HTML Editor. Note: When you start editing the content the editor window will automatically expand. See number 25 below.  

New Rich Content Editor screen

1-Font Sizes

Code Example:

<span style="font-size: x-large;">some text</span>‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍


Uses the span element and inline CSS (the style attribute) to create the larger text. It is generally not recommended to use this option to create header in your content. Header content should be properly marked up using the header elements. See number 2 below. 

2-Paragraph and Header Elements

Code Example:

As you type content in the editor, each time you press the Return/Enter key a new paragraph is created. Paragraphs will have specified paddings and margins from the linked CSS document.  You can mark up headers using the paragraph drop down menu. Select text you want to be a header and mark as header (H2), sub-header (H3), or small header (H4). The heading 1 is the title of the page and will display in the browser tab when somebody visits the page. Properly marked headings are important for people who use alternative browsers such as screen readers to access your content. 

You can use the style attribute to change the font and margins if desired to have a different look that the default editor settings. I generally don't recommend doing that for all your pages because you must edit each element to make this change. That is too much work. A better option would be to look at getting Design Tools Plus installed in your Canvas instance. Contact your IT people to see if it possible. This is basically the commercial version of Kennethware. At Lake Land College we have been using for year now and it is super helpful to build out nicely designed pages without really needing to know HTML. 

Headings and Paragraphs

<p>Some body text</p>‍‍‍‍‍‍‍‍‍
<p>Some body text</p>‍‍‍‍‍‍‍‍‍
<h4>Small Header</h4>
<p>Some body text</p>‍‍‍‍‍‍‍‍‍

Preformatting Text

When you use the pre element the text will display highlighted similar to what you see here and formatting with mono spaced font. 

<pre>Some Text that will display as you type it</pre>‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍


Paragraphs and headings are considered structural elements in HTML and are essential to making your pages accessible to all. For further reading, visit the WebAIM articles, Semantic Structure and Designing for Screen Reader Compatibility. I also recommend viewing the recording of the CanvasLIVE webinar  and joining the Canvas Mobile Users Group and Accessibility Users Group. Both groups are great resources for learning more about design content for accessibility. 


Code example:

<strong>Some Text</strong>‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍


The Strong element is used bold text. It is generally not recommended to use the strong element to create page headings. Use the actual heading elements to create this type of structure. See number 2 above for details on why this is important.


Code Example:

<em>Some Text</em>‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍


Italics should be used to emphasize text and should be used sparely on webpages. Depending on font it can be hard to read italicized text on monitor.


Code Example:

<u>Some Text</u>‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍


This element can be used to emphasize text; however, in on webpages underlined text is often confused with hyperlink text. I generally don't recommend using this element.

6-Text Color

Code Example:

<span style="color: #ff0000;">Some Text</span‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍


This command creates a span element and inline CSS (the style attribute) to create the colored text. The style attribute can be applied to any text element such as paragraphs and headers. In the toolbar there are only about 20 colors to choose from; however, in the new editor you can use the color picker (color palette icon) to choose a color or enter hex code. See Resources for Hex Colors for details on how to find hex colors. 

7-Background Color

Code Example:

<span style="background-color: #ff9900;">content</span>‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍


This command uses the span element and inline CSS (the style attribute) to create the background color. The new editor will also have the same options as text color so you can pick your own colors or use hex color. This should be used cautiously with text. If the background color and text color do not have enough contrast between them, the text can be hard to read. In the example below the text is hard to read. This can be especially hard on color blind people or people like who are losing their sight to old age like me. For further reading, view this Smashing Magazine article, Design Accessibly, See Differently: Color Contrast Tips And Tools.

On a side note, the Jive editor does not have background color element in the toolbar and does strip it when you try to add in code view so I had to use an image for this example.

example of bad contrast


Code Examples:



Be sure to only select the text that should be superscript or subscript when applying this command. It appears this option toggles between superscript and subscript. You can always switch to code view to fix any issues that you might not be able to fix with the toolbar.

9-Text Alignment

Code Examples:

There are three alignment options and they are grouped together in one menu item. These attributes can be applied to headings and paragraph elements. The left alignment is the default in the editor. Note: It is best to only use center and right alignment for headers or short lines of text. It is generally not recommended for longer lines of text because centered text is harder to read.

<p style="text-align: left;">Paragraph of text</p> 

<p style="text-align: center;">Paragraph of text</p>

<p style="text-align: right;">Paragraph of text</p>‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍



For further reading I recommend the WebAIM articles, Writing Clearly and Simply and Text/Typographical Layout.

10- Lists (Unordered and Numbered)

In the new editor all the lists are now under one menu with the unordered (bullet) list as the default. There are also options for setting different bullet or numbering options.  

Code Example for Unordered List:


<li>List Item</li>

<li>List item</li>

<li>List Item</li>



Unordered lists are good for list of items where the sequence of the items does not matter. Lists can be nested using the indent option. 

Code Example for Numbered List:


<li>Do this first</li>

<li>Do this second</li>

<li>Do this third</li>




Order lists are good when you are giving students a set of an instructions for homework assignments. Below is example of ordered list coded with letters. See example code below.

<ol type="a">

<li>Do this first</li>

<li>Do this second</li>

<li>Do this third</li>


11- Outdent/Indent

Code Example:

What this option does depends on element it is applied to in the code. This is also toggle switch like the sub/super script options. See examples below.

When applied to paragraph element the style attribute is applied to the paragraph element with padding of 30 pixels.

<p style="padding-left: 30px;">Some text</p>‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

When applied to an unordered or ordered list a new nested list is created.


<li>Some Text</li>


<li>Some indented text</li>



12-Text Direction

Code Example:

<p dir="rtl">Some text</p>‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍


This attribute is essential for setting how script languages will display on the webpage. For more details, go to the WC3 article, Structural markup and right-to-left text in HTML

13-External and Course Links

Code Example:

To add a link select the link icon. There will be two options to select. Use the external option for adding links from websites outside of Canvas. When selecting the external option a dialog box will appear where you can paste the full URL for a website. When selecting the course link option the sidebar will display allowing you to choose desired content you want to link to on the page. If you do not select text in the editor, the name of the link will display in the editor once you select the item in the sidebar. When you select a link in the editor it will be highlighted. When link is highlighted,  you click the link icon in the toolbar to edit or remove the link. Below is example of the code will appear for links.  

<a href="">Google</a>
<a title="Exam Quiz" href="">Exam Quiz</a>


The color of the link is controlled by the CSS (Cascading Style Sheets) that is linked to the HTML document. See Canvas Styleguide for more details. For further reading, read the WebAIM article, Links and Hypertext and Accessible CSS.


Code Example:

Images can be pulled from you computer, the web, or Canvas files.The super great news here is that students will have the exact same options that instructors have!! No more crazy convoluted instructions telling students how to upload an image! When you embed an image in the editor you will see options bubble above or below the image (depends on the layout of the page). When you click the options the sidebar will appear and this will allow you to add or modify the alternative text and set some other parameters. Be sure to click Done when finished. You can also resize an image when it is selected in the editor. In the code example below, I selected the image and used the alignment option (see number 9 above) to float the image to the right. The picture, record/upload media, and documents options will have drag and drop options for uploading documents. 

<img style="float: right;" src=";q=80&amp;fm=jpg&amp;crop=entropy&amp;cs=tinysrgb&amp;w=1080&amp;fit=max&amp;ixid=eyJhcHBfaWQiOjc2MDc1fQ" alt="Photo of boxer dog" width="185" height="123" data-is-decorative="false" />‍‍‍‍‍‍‍‍‍‍‍‍‍‍


For further reading, read the WebAIM article, Accessible Images.

15-Record/Upload Media

Note: Update as of 1/1/2020. 

Update: The Record/Upload Media option has three options.

  • Upload/Record Media - You can upload media, record webcam video, or embed video share code. The record option will allow you to record video or audio using webcam/microphone. This option will use HTML5 in Chrome and Firefox. When you upload using this option, the media is NOT stored in course files and will not count against the storage limit. Uploads are limited to 500 MB. The embed option allows you to paste the embed code from a site like YouTube. 
  • Course Media - You can upload media to your course files. It should be noted any media uploaded to files will count against the storage limit. 
  • My  MediaYou can upload media to your personal files. It should be noted any media uploaded to files will count against the storage limit. 

Example Code for YouTube Embed

Update as of 1/1/2020: The embed option will still be available here as well as the Upload/Record Media option. Thank you stefaniesanders and  @chofer  for pointing that is option is available.  The embed option allows you to add a share link or embed code from a video on video sharing site like YouTube, Vimeo, or Teacher Tube without needing to switch to HTML view. On the keyboard click ALT + F9 to display the toolbar menu. In the menu, click Insert > Media.In the dialog box paste the link on the general option or select Embed to paste the code. Additionally, you can switch to HTML view to paste code. See 24 below. 

<iframe width="560" height="315" src="" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>‍‍‍‍‍‍‍‍‍‍‍‍‍‍

16-Insert File

This option is partially new and combines the upload and sidebar options in to one menu in the toolbar. All users can now upload files in the editor. The process will be similar to images. Once the link is placed in the editor an options bubble will appear when you select the link. When options bubble is selected the right sidebar will display. You can choose to link to the document or select the embed preview option. You can also edit the text or change the link. 

Example Code

<a title="My Backup Plan.docx" href="">My Backup Plan.docx</a>

17-Clear Formatting


This option is handy for getting rid of the extra HTML code that sometimes comes over when you copy and paste text from other locations such as from Word or other websites. It is important to note that this option works with most elements but doesn't seem to work with the background element (see number 7 above). You can select the text and use the clear formatting option to remove the color choices. 


Code Example:

Table code involves several different elements that work together to create a table. The table editor has been improving over time so you can apply a lot of the attribute elements directly in the editor. See code example below.

<table border="0">
<td>Row 1</td>
<td>Row 2</td>


I will note that tables should only be used for tabular data; however, the majority of people do not use them this way. This stems from some bad web design hacks from the late 90s which can still spark heated debate about their use in designing webpages. The key point to remember is that you want your pages to be accessible to all. For further reading, visit the WebAIM article, Creating Accessible Tables.

19-Math Equations

Code Example:

When this option is used in the editor the equation editor will display. You can use the editor options or write the equations in LaTex. The equation will be rendered as an image with the LaTex as alternative text.

<img class="equation_image" title="\frac{3}{4}+5" src="/equation_images/%255Cfrac%257B3%257D%257B4%257D%2B5" alt="\frac{3}{4}+5" />‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍


Check out the Canvas Equation Editor Tips in the Canvas Community for tips on writing math equations. 

20-LTI Tools

In the old rich content editor many of these options would display directly on the toolbar and others would be hidden in the V icon on the toolbar. Now they are all consolidated into one menu (plug icon). The options in the menu will vary from institution to institution so no code examples here. One option that all institutions will have is the Commons Favorites (if enabled). See the following guides for details. 

21-Keyboard Shortcuts

The keyboard shortcut icon was added recently and provides a quick view of the keyboard shortcuts you can use with rich content editor. One of my favorite keyboard shortcuts is to show the menu bar using ALT+F9. There are a few commands that can only be found there. Namely, the Strikethrough element, more font options, and a more detailed word count summary.

Code Example of Strikethrough and Font Elements

Both of these options are added as span element and inline CSS. You can use the clear formatting (see number 17 for details) to remove any span element from the text in the editor. 

<span style="text-decoration: line-through;">Text</span>
<span style="font-family: georgia, palatino, serif;">Text with different font choice</span>‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

22-Accessibility Checker

This option allows you to check the accessibility of content page you are currently editing. When you select this option the checker will appear in the sidebar. If there are issues, it will give you options to correct the issue. Review the following guide. 

24-HTML View

Use the HTML editor to switch to code view so you can edit the code. Please note there are only certain HTML elements (Tags) that are allowed in the editor and any elements added that are not allowed will be stripped out of the page when you save the page

25-Resize the Editor Window

When you start editing a page the editor window will automatically expand. When the editor window expands you will lose the scroll bar. You can use this corner handle to resize the window so the scroll bar comes back. Unfortunately, the next edit you do will expand the editor window again. See the feature ideas below for suggested improvements to the editor. 

Additional Resources

Related Feature Ideas

Below are some feature ideas about the new editor. Please take a look each one and add your comments. This helps to improve the user experience. 

19 9 5,292