Canvas LMS
Canvas LMS Integration
A Canvas install has three parts: register NotAI in Canvas, turn on Canvas Live Events, and add the NotAI theme file in the Canvas Theme Editor. This guide walks through every step; your NotAI contact sends your registration link, Live Events address and theme file. The theme file runs on every page in your Canvas instance, including assignments, quizzes, discussions, and SpeedGrader. If you need detection limited to specific courses rather than the whole instance, see Course scoping. This guide is for Canvas administrators; instructors do not need to do anything.
Overview
This page covers the Canvas-specific install of the NotAI script. The NotAI script installs anywhere; Canvas has its own install shape because the Theme Editor accepts JavaScript file uploads rather than raw HTML, so the NotAI script is attached via a small DOM-injection snippet instead of a <script> tag. The runtime behavior is identical to any other install.
Once the theme upload is live, the NotAI script observes behavioral signals on every Canvas page and reports them to your NotAI dashboard. Reviewer features that attribute sessions to specific students are included with academic plans and are configured from inside your dashboard once the NotAI script is reporting. See Reviewer features. For procurement, student privacy terms live in the Data Processing Agreement and the NY Ed Law 2-d notice. Your institution is responsible for telling students that NotAI runs in Canvas; the student notice is the text we give schools to adapt.
Requirements
- Canvas admin access at the root account, for the registration and Canvas Live Events (steps 2 and 3), and at the account whose theme you change (step 8).
- A NotAI account. For a school, NotAI sets up the account and sends what you need (see Before you start). You can also create an account; your 8-character integration ID is in the dashboard.
- Network access from student devices. If your district filters the web on student devices, allow NotAI's hosts. See Network requirements and school web filters.
- An academic plan, if you want the reviewer features (authorship orbs and session replay tied to specific students). See academic pricing.
Supported Canvas versions
- Canvas Cloud (Instructure-hosted)
- Canvas Self-Hosted (all versions currently supported by Instructure)
Installation
A Canvas install takes about 30 minutes for a Canvas administrator, with one step for your IT team. Do the steps in order: choose the courses and tell your students (steps 5 to 7) before you add the theme file (step 8), because NotAI starts running on student pages as soon as the theme is applied.
Before you start
Your NotAI contact sends you:
- A welcome email to each person who will manage your NotAI settings. Each needs a real mailbox: NotAI signs you in with a link it emails you, and there is no password.
- Your registration link for Canvas. It works once; keep it private.
- Your Live Events address.
- Your theme file, a small JavaScript file.
- The student notice, with a short and a long version.
Ask your IT team to allow NotAI if you filter the web on student devices. Some web filters put NotAI in the wrong category and block it without any message: Canvas keeps working, and NotAI simply sees nothing. Allow isnotai.com and isnot.ai, including their subdomains. See Network requirements and school web filters, or run the device check on a managed student device.
Step 1: Sign in to the NotAI dashboard
- Go to https://dash.isnotai.com.
- Enter the email address your welcome email was sent to, and ask for a sign-in link.
- Open the link in the email we send you. It works once and expires soon; if it has expired, ask for a new one.
Step 2: Register NotAI in Canvas
Do this at your root account, in one sitting, without refreshing the page.
- In Canvas, go to Admin, then your root account, then Developer Keys. Choose + Developer Key, then + LTI Registration.
- Paste your registration link and continue.
- Canvas walks you through its setup steps (Permissions, Data Sharing, Placements, Naming, Icons). Choose Next through them. On the Data Sharing step, keep the privacy level NotAI asks for: Public (all user data). With less, NotAI can't tell you which student a session belongs to.
- On the last step, Review, finish with Enable & Close. (If you started from Apps instead of Developer Keys, the button is Install App.)
- Back in Developer Keys, make sure the new NotAI Dashboard key is switched ON. Canvas creates it switched off.
If you closed the window before the last step, the link is used up: ask us for a new one. Teachers don't see NotAI in their courses. To give a teacher access to the dashboard, invite them from the dashboard's Team page.
Using NotAI in only part of your school. Canvas makes NotAI available across your whole Canvas after registration. To use it in one sub-account only, deploy NotAI Dashboard in that sub-account and remove the deployment Canvas created at the root. We are happy to walk you through it.
Step 3: Turn on Canvas Live Events
Live Events let NotAI see quiz and assignment activity from Canvas itself, including for students whose browser blocks the NotAI script.
- In Canvas, go to Admin, then your root account, then Data Services, then Add. Subscribe at the root account. If you don't see Data Services, ask Instructure to turn it on for your Canvas.
- Fill in: Delivery: HTTPS. URL: your Live Events address, exactly as we sent it. Sign Payload: ON (required; NotAI refuses unsigned deliveries). Format: JSON (not Caliper).
- Choose the event types. Required:
asset_accessed,quiz_submitted,submission_created,submission_updated. Recommended:logged_in,logged_out,course_created,course_updated,assignment_created,assignment_updated,user_created,user_updated. Optional:discussion_entry_created,discussion_entry_submitted. - Save.
Step 4: Check your allowed origins
NotAI only accepts activity from the Canvas addresses on your list, so a page from any other address is ignored. In the dashboard, open Settings, then Pixel Install, then Allowed Origins (the list is also on your integration's page). You should see your Canvas address, for example https://yourschool.instructure.com. If students also reach Canvas through a school address (such as https://canvas.yourschool.edu), tell us so we add it.
Step 5: Choose the courses
NotAI runs in all your courses unless you limit it. In the dashboard, open Settings, then Pixel Install, and find Courses (also on your integration's page). Choose All courses, Only these, or All except these; for the last two, add the Canvas course numbers (the number in the course's address). Save. The change takes effect within about 10 minutes, and you never change the theme file for it. See Course scoping.
Step 6: Writing capture (optional, US schools)
Writing capture records what students write or paste in assignment text boxes, quiz essay answers and discussion replies, so your staff can replay how an answer was written. It is off until you turn it on: in the dashboard, open Settings, then Pixel Install, and set Writing capture to On. Your student notice must then say it's on. If the setting shows "Available on request", NotAI has not turned writing capture on for your account yet: ask your NotAI contact.
Step 7: Tell your students
- Open the student notice we sent you and choose the sentences that match your settings (courses, writing capture, and whether the real-time pause is on).
- Post the short version where students see it before they reach a page NotAI runs on, such as your Canvas sign-in page or a global announcement.
- Put the long version in your syllabus, student handbook or privacy page. Students can also read the student notice here.
- If you change your settings later, post a new announcement. Canvas does not show an edited announcement again to students who dismissed it.
Step 8: Add the NotAI file to your Canvas theme
Canvas's Theme Editor takes a JavaScript file. Use the file we sent you.
- Decide where to add it: the root account to cover your whole school, or the sub-account that covers the courses NotAI should run in. Add it once: Canvas also runs theme files from every account above a course. See Root and sub-account installs together.
- Go to Admin, then that account, then Themes. Open the active theme in the Theme Editor.
- On the Upload tab, upload the file as the JavaScript file: our file, or your combined file.
- Choose Save Theme, then Apply Theme.
For reference, the file looks like this, with your integration ID in place of a7f3c2e1. You never need to change it for courses or writing capture.
// NotAI for Canvas LMS
;(function() {
const s = document.createElement('script');
s.src = 'https://cdn.isnotai.com/api.js';
s.async = true;
s.setAttribute('data-key', 'a7f3c2e1');
document.head.appendChild(s);
})();
Step 9: Check the first session
- Sign in to Canvas with a real test student account (not Canvas's Student View), on a device that goes through your normal web filter.
- Open a page in a course NotAI covers (step 5).
- In the dashboard, open Sessions. Within a few minutes, a new session appears from that student, with the course it came from.
- If you turned on writing capture (step 6), have the test student type in an assignment text box: their writing appears on the Sessions page's Writing tab.
If nothing appears after 10 minutes, see Troubleshooting: the web filter is the usual cause.
Root and sub-account installs together
Most schools install NotAI once, in the root account's theme, and that covers every page. This section is for one case only: a sub-account uses a different NotAI integration from the root account, for example a college with its own NotAI account under a university-wide install. A school with one integration in the root account never needs it, and neither does a sub-account that uses the same integration ID as the root account: NotAI runs once per page.
Why it is needed. A sub-account theme does not replace the root account's JavaScript. On every page, Canvas runs the theme JavaScript of every account up the chain, so on a page in that sub-account both installs load. Without a priority, the page would be recorded in both NotAI accounts.
The fix is one line. Give the sub-account's install a higher priority. On each page, only the install with the highest priority runs; the others do nothing on that page, so they send nothing and store nothing.
Sub-account theme file
The usual install, plus a priority:
// NotAI for Canvas LMS (sub-account)
;(function() {
const s = document.createElement('script');
s.src = 'https://cdn.isnotai.com/api.js';
s.async = true;
s.setAttribute('data-key', 'b1c2d3e4');
s.setAttribute('data-priority', '10');
document.head.appendChild(s);
})();
Root account theme file
The usual install from Installation, unchanged. With no priority it counts as 0, so on the sub-account's pages it steps aside, and everywhere else it runs as before.
Replace a7f3c2e1 (root account) and b1c2d3e4 (sub-account) with your two integration IDs. EU accounts add s.setAttribute('data-region', 'eu'); on the line before document.head.appendChild(s); in their file, as in the main install. Courses and writing capture stay in the dashboard, for each integration.
How priority works
- The highest priority runs. A priority is a whole number from 0 to 100. A missing or invalid value counts as 0. Leave gaps (10, 20, and so on), so that a deeper sub-account can later sit above its parent.
- Only pages with both installs. On a page outside the sub-account, Canvas loads only the root account's theme, so the root install runs as before.
- Equal priorities all run. That is why installs without a priority behave exactly as before. To make one install stand aside, give the other a higher number.
- Same integration twice. Several installs of one integration count as one, at that integration's highest priority, and NotAI runs once.
- Decided once per page. The page decides after it has loaded. An install added later runs only if its priority equals the winner's, and it never stops one that is already running.
- Use the same script source (CDN or self-hosted) for all installs that set a priority. An install counts while the page decides even if its script then fails to load, for example when a web filter blocks only one address or a self-hosted file is missing. If that was the higher one, the page runs neither. With one source, a block stops both installs alike.
- The mobile apps too. If your themes also carry a JavaScript file for the Canvas mobile apps, add the same priority line there.
- With DesignPLUS or another tool. Canvas allows one JavaScript file per theme. If an account's theme already has one (for example Cidi Labs DesignPLUS), keep that tool's code: replace only an existing NotAI block with that account's file above, and add it to the end of the file only where there is no NotAI code yet.
Already using the wrapped root install?
The wrapped root install and the sub-account's window.__x9s line, from an earlier version of this guide, keep working. To simplify, give the sub-account's install a priority and put the root account back on the usual install, in this order:
- Add the priority line to the sub-account's file, and save and apply the theme.
- Then replace the root account's wrapped NotAI block with the usual install.
In the other order, both installs briefly have the same priority (0), and both run.
Configuration
The theme file carries your integration ID and, for EU accounts, the region; a sub-account with its own integration also sets a priority (see Root and sub-account installs). Nothing else goes in it. Choose courses and turn writing capture on or off in the NotAI dashboard, under Settings, then Pixel Install; changes take effect within about 10 minutes.
Attributes
| Attribute | Default | Description |
|---|---|---|
data-key |
Required | Your 8-character integration ID. |
data-region |
us |
Reporting region. us or eu. Must match the region configured for your account. EU accounts add s.setAttribute('data-region', 'eu'); on the line before document.head.appendChild(s);. |
Course scoping
A theme upload applies to your whole Canvas instance, so by default the NotAI script runs on every page. Course scoping narrows that to the courses you choose, which is useful for pilots, for a single department, or for honoring an opt-out.
Choose courses in the NotAI dashboard: open the integration's Courses card, on the integration's page or under Settings, then Pixel Install, and choose All courses, Only these courses, or All courses except these. Changes take effect within about 10 minutes, with no change to the theme file.
Course IDs are the numbers Canvas puts in course URLs. The course at https://yourschool.instructure.com/courses/1470 has the ID 1470. A course code such as MATH-101 is not a course ID.
How a page's course is determined
The NotAI script reads the course from the /courses/{id} segment of the page URL whenever it is present, including sub-path installs such as /lms/courses/1470/assignments/9. For the few course pages whose URL does not carry that segment, it falls back to the course Canvas publishes in the page environment.
Canvas moves between sections without reloading the page, so the NotAI script re-checks the scope on each of those in-page navigations as well as on page load. If a navigation lands on a course outside your scope, the NotAI script shuts itself down: it sends the data it collected while it was in scope, then removes every listener and stops. It stays stopped until the next full page load, so returning to an in-scope course in the same page view will not restart it. This is deliberate: it errs toward not running, at the cost of occasionally missing a course you scoped it into.
Pages that are not part of a course
Canvas has many pages with no course context: the dashboard, account and admin pages, the calendar, and the inbox. Scoping treats them as follows.
| Page | Only these courses | All courses except these |
|---|---|---|
| Page in a listed course | Runs | Does not run |
| Page in an unlisted course | Does not run | Runs |
| Page with no course (dashboard, account, calendar, inbox) | Does not run | Runs |
| Course page where the course cannot be determined | Does not run | Runs |
Only these courses is a statement about which courses to monitor, so it never runs outside them. All courses except these is a statement about which courses to leave alone, so it runs anywhere it has not been told to stop. Both rules hold even when the course cannot be identified, and that last row is where the two differ in a way worth knowing.
cdn.isnotai.com, because the course check runs inside the script, and the script then reads your course scope from NotAI, one request whose path starts with /ws/scope/; it fetches your integration's whole course list and carries nothing about the page. The browser often serves both from its cache. A scoped-out page makes no other request to NotAI.
Verifying your scope
Load each page below fresh, by pasting its URL into the address bar or reloading, rather than clicking through Canvas. Clicking through uses the in-page navigation described above, which means leaving a monitored course shuts the NotAI script down for the rest of that page view and sends one final batch on the way out. Both are correct, and both will make a working configuration look wrong if you are watching the Network tab while browsing.
- Load a page inside a course that should be monitored. In Developer Tools, on the Network tab, confirm requests to your reporting host appear.
- Load a page in a course that should not be monitored. Confirm nothing is reported: the only requests to NotAI may be the script download from
cdn.isnotai.comand the course scope read described above (its path starts with/ws/scope/). - Load a non-course page such as the dashboard. What to expect depends on what you chose: with Only these courses there should be no request to NotAI beyond those two, and with All courses except these there should be requests to your reporting host, because the dashboard is not in an excluded course. Check this against the table above rather than assuming silence means success.
- In your NotAI dashboard, check that new sessions carry only the courses you scoped to.
If pages you expect to be monitored stop reporting, check the course IDs on the Courses card against the course URLs, and allow about 10 minutes after a change.
Writing capture
Writing capture records what students write or paste inside Canvas editors (assignment submissions, discussion posts, quiz essay responses) so it can be replayed and its authorship classified at the session level. It is off by default. Choose courses and turn writing capture on or off in the NotAI dashboard, under Settings, then Pixel Install; changes take effect within about 10 minutes. The theme file needs no change.
Writing capture is available for US-region accounts only, on request: until NotAI turns it on for your account, the dashboard's On setting shows "Available on request". Before you turn it on, tell your students that it records what they write; the student notice covers it.
It covers Canvas's Rich Content Editor (RCE) and the standard form surfaces.
Reviewer features
The theme file is what detects AI agents and bots at the session level. The Canvas registration (step 2) is what lets NotAI tell you which student a session belongs to, and Canvas Live Events (step 3) add Canvas's own quiz and assignment activity. Reviewer features (authorship orbs tied to specific students, full session replay for suspected essays where writing capture is on in the US region, and the instructor-facing reviewer UI inside your NotAI dashboard) are included with academic plans.
Beyond the install steps there is nothing else to set up: the theme file needs no changes for them. Attribution relies on identity fields your institution chooses to provide, listed in the Data Processing Agreement.
For tiers and eligibility, see academic pricing.
Testing
Verify the install after applying the theme.
Confirm the script loads
- Open any Canvas page in your browser.
- Open Developer Tools (F12 or Cmd+Option+I) and select the Network tab.
- Filter by
cdn.isnotai.com. - Confirm
api.jsloads with a 200 status.
Confirm sessions reach your dashboard
- Log in to your NotAI dashboard.
- Navigate to Sessions.
- Look for sessions with a hostname that matches your Canvas domain (for example,
yourschool.instructure.com).
Sessions appear within seconds of the first signal. If you do not see any, check the Troubleshooting section.
Dashboard
All Canvas sessions surface in the NotAI dashboard alongside sessions from any other integration. Each session carries a verdict (Clean, Suspicious, or Bot) and the signal evidence behind it. On academic plans, reviewer features add authorship orbs and session replay inside the dashboard itself.
Session data is also available through the NotAI Public REST API, documented at /developers.
Content Security Policy
Canvas does not set a default Content Security Policy that blocks the NotAI script. If your institution has added a custom CSP at a proxy or WAF in front of Canvas, allow the script host and the reporting host for your region.
United States
Content-Security-Policy:
script-src 'self' https://cdn.isnotai.com;
connect-src 'self' https://chl.isnot.ai wss://chl.isnot.ai;
European Union
Content-Security-Policy:
script-src 'self' https://cdn.isnotai.com;
connect-src 'self' https://chl-eu.isnot.ai wss://chl-eu.isnot.ai;
Only the reporting host differs between regions. Both regions use the same script host.
Troubleshooting
The script does not load
- Confirm
data-keymatches the integration ID from your NotAI dashboard exactly. - Confirm your Canvas domain (for example,
yourschool.instructure.com) is on your integration's allowed origins. Check them in the dashboard: open Settings, then Pixel Install, then Allowed Origins, or on the integration's page. Requests from origins outside the list are rejected. - Confirm the theme is saved and applied. Saving without applying will not propagate the upload.
- Clear your browser cache and reload.
- Check the browser console for CSP violations.
- On school-managed devices, check that your web filter allows NotAI's hosts: open
https://cdn.isnotai.com/api.json a student device, or run the device check there. See Network requirements and school web filters.
The script loads but no sessions appear
- Confirm
data-regionmatches the region configured for your account. - If you chose courses in the dashboard, confirm the page's course is in scope. See Course scoping.
- Confirm the dashboard is filtered to the correct integration.
Theme changes not appearing
- Ensure you clicked both Save Theme and Apply Theme.
- Wait a few minutes for changes to propagate.
- View the page in an incognito window to bypass browser caching.
- Check that no other theme is overriding the one you edited.
False positives
- Users with assistive technology can produce patterns that overlap with automation.
- Remote desktop sessions can surface bot-like pointer traces.
- Review ambiguous sessions in the dashboard before taking action.
Performance
- The script loads asynchronously and does not block Canvas page rendering.
Still stuck? Support usually replies within a business day.
Contact support