Canvas AI Detector: Check Assignments for AI

Canvas is where the submission lives, but Canvas itself has no opinion about whether a student wrote it. Assignments come in as text entries or uploaded files, you open them in SpeedGrader, and the only integrity signal Canvas shows you is whatever your institution has separately licensed. If your school pays for Turnitin, its AI report appears alongside the submission inside Canvas; if not, you see nothing at all.

Either way, the moment usually arrives the same way: you're partway through a stack of grading and one essay reads wrong. The vocabulary jumped a level. Every paragraph is the same shape. The conclusion summarises points the essay never quite made. That is the moment this workflow is for.

One thing first, honestly: TheChecker.AI does not install into Canvas. There is no LTI plugin and no integration to configure. It is a paste-based second-opinion tool that sits alongside your LMS — which, in practice, is also why it takes zero setup and no IT ticket.

The SpeedGrader workflow, step by step

The whole check fits inside the grading pass you were already doing.

1. Open the submission in SpeedGrader. For text-entry assignments the writing is right there in the preview pane. For uploaded documents, use the inline preview or download the file and open it.
2. Select and copy the text. Copy the passage that made you pause — or the whole essay. Sentence-level results are most useful when the detector sees full paragraphs rather than fragments, so err on the side of more context.
3. Paste it into the free demo. No account, and nothing you paste is stored. Results come back in seconds.
4. Read the map, not just the number. Note which sentences are highlighted and which model the text resembles, then go back to SpeedGrader and leave your feedback as usual.

If you grade in the browser all day, the Chrome extension shortens step two and three: check text where you're reading it instead of switching tabs. And if your institution wants this at scale rather than teacher-by-teacher, the REST API lets your own developers build checking into whatever pipeline you already run — that's an engineering project on your side, not a plugin we ship.

Reading the result

TheChecker.AI returns two things a single percentage can't give you.

A sentence map. Each sentence is scored, so you can see whether a 45% result means "the whole essay is borderline" or "three paragraphs are almost certainly generated and the rest is the student's voice." Those are very different conversations, and the map tells you which one you're having. Mixed submissions — a human draft with an AI-polished conclusion — show up as exactly that.

The likely model, named. The text is compared against more than 40 models, including GPT-4 and GPT-5, Claude 3 and 3.5, Gemini Ultra, Llama 3 and Mistral, and the result names the one it most resembles. "This section reads like ChatGPT output" is a concrete, checkable observation; "AI detected" is not.

In our own benchmark the detector reaches 93% accuracy — the accuracy page explains exactly how that figure is measured and what it does and does not claim.

If your school already has Turnitin in Canvas

Many Canvas institutions license Turnitin, and its AI writing report appears right in the grading flow. Use it — but remember what a second opinion is for. When Turnitin flags a submission, running the same text through a detector that reasons differently and shows different evidence (per-sentence scores, the likely model) tells you whether the flag is corroborated or shaky. When two independent tools disagree, that itself is information. The Turnitin comparison covers where each tool starts and stops.

Before you act on a flag

A score is a signal, never a verdict. Formulaic writing, non-native phrasing, and heavily edited prose can all raise scores on every detector on the market, ours included. Three habits keep a statistical tool from becoming an unfair one:

• Look at the evidence, not the total. The sentence map exists so you can see why the score is what it is before you decide anything.
• Ask about the process. Canvas shows you the finished artifact; the student can show you the drafting. If the work started life in Google Docs, revision history is often the most decisive evidence available — the Google Docs workflow covers how to read it.
• Start a conversation, not a case. "Walk me through how you built this argument" resolves most flags in five minutes, in whichever direction the truth lies.

This is the same approach we recommend to every educator, detector or no detector — the teachers page lays out the full classroom workflow, and more than 10,000 educators across 500+ institutions use it in exactly this second-opinion role. If Canvas checks become routine for you, a paid plan removes the demo's limits.

Checking a whole class efficiently

The tempting version of this workflow — paste all 120 submissions through the detector, one by one — is the wrong version. It burns an evening, it treats every student as a suspect, and it multiplies the false-positive problem: run enough honest essays through any detector and some will score high purely by the statistics of formulaic writing. Screening everyone means you will generate flags on innocent work, and each one costs you a conversation you didn't need to have.

Triage instead. Grade the way you always have, and let your own reading do the first pass — you already notice when a submission doesn't sound like the student who wrote the last three. The essays that earn a check are the ones where something specific reads oddly: a register jump, an argument structure the course never taught, suspiciously uniform paragraphing, sources that feel decorative. In a typical stack that's a handful of submissions, not the whole gradebook, and a handful of pastes is five minutes of work.

For instructors running large sections, the professors page covers this triage discipline in more depth, including how to calibrate the detector on writing whose origin you already know — your own drafts, past student work with a known history — before you ever point it at a live submission. And if your institution truly wants systematic coverage rather than instructor judgement, that is what the REST API is for: your developers decide what gets checked and when, on infrastructure you control.

Edge cases: file uploads, scans and discussions

Paste-based checking has one hard requirement: selectable text. Most Canvas submissions clear that bar easily, but a few shapes deserve care.

File-upload PDFs usually copy cleanly from the preview or the downloaded file. Check the paste before you submit it, though — PDFs exported from unusual tools sometimes mangle line breaks or drop ligatures, and a detector scoring garbled text tells you nothing useful. If the paste looks wrong, open the original file and copy from there.

Scanned or photographed work — a handwritten exam scanned to PDF, a photo of notebook pages — has no text layer at all. There is nothing to paste, so there is nothing this workflow can see. That's worth saying plainly: a detector reads text, and handwriting on paper is, for better or worse, outside its reach.

Discussion posts and quiz essay answers are fair game. Anything in Canvas you can select and copy — a discussion reply, an essay-question response, a peer review — can go through the same paste-and-read loop as an assignment.

Group submissions blur authorship by design. A sentence map showing one flagged section in a collaborative document tells you which part reads as generated, but not which group member produced it — keep that limit in mind before addressing anyone individually.

What to put in your syllabus

The cheapest integrity intervention happens before any submission exists: a clear, honest policy students read in week one. Vague bans invite vague compliance; a specific paragraph gives everyone the same rules. Wording you can adapt to your own course (this is course policy language, not legal advice):

Work you submit in this course must be your own writing. You may not submit text generated by AI tools as your own. [Choose one: AI tools may not be used at any stage of assignments / AI tools may be used for brainstorming and feedback, but every submitted sentence must be written by you — and any AI use must be disclosed in a note at the end.] I may check submissions with an AI detection tool. A detector score alone will never decide an integrity case: if your work is flagged, we will talk, and your drafts and revision history will count in your favour. Keeping your drafting evidence protects you.

Two things make language like this work. It states where the line is for your course, since reasonable instructors draw it differently. And it commits you to the fair process this page describes — which also tells honest students exactly how to protect themselves. Students who want to understand that side of the equation, including why sincere writing sometimes gets flagged, can be pointed at the students page.

Building the evidence file

If a conversation doesn't resolve a flag and the case moves toward a formal integrity process, what you saved in the first ten minutes matters more than anything you reconstruct later. Before the conversation, capture:

• The flagged text itself, exactly as submitted, with the submission timestamp from Canvas.
• The sentence map — which specific sentences drove the score, not just the overall number. "Paragraphs three through five, sentence by sentence" is evidence; "67%" is an argument.
• The named model. If the result says the text reads like GPT-5, note it — the GPT-5 detection page explains what that resemblance does and doesn't establish.
• Your independent observations: the register shift from earlier work, the citation that doesn't support its claim, the concept the course never covered. These stand on their own even if the detector score is challenged.
• The student's account and drafting evidence — outlines, notes, and version history if the work started in Google Docs. File these whichever way they point; evidence that clears a student belongs in the record just as much.

A file like this keeps the process honest in both directions: it stops a shaky flag from hardening into an accusation, and it gives a solid one the specificity an integrity panel needs.

Frequently asked questions

Does Canvas have built-in AI detection?

No. Canvas itself does not detect AI-generated writing. Some institutions license Turnitin, whose AI report can appear alongside submissions inside Canvas, but that depends entirely on what your institution has bought and enabled.

Is there a TheChecker.AI plugin for Canvas?

No, and we won't pretend otherwise. TheChecker.AI is a paste-based tool that sits alongside Canvas: you copy text from SpeedGrader and paste it into the checker. There is also a Chrome extension for checking text in the browser, and a REST API that an institution's developers could wire into their own pipeline.

How do I check a Canvas submission for AI?

Open the submission in SpeedGrader, select and copy the student's text, and paste it into TheChecker.AI's free demo. In seconds you get a sentence-level map of which passages read as AI-generated and the model the text most resembles. Nothing you paste is stored.

What if the detector flags a student's essay?

Treat it as a signal, not a verdict. Every AI detector produces false positives, including ours. Look at which sentences drove the score, ask the student about their drafting process, and never act on the number alone.

Can I check every submission in a Canvas course at once?

Not through the free demo, which checks one pasted text at a time. In practice you rarely need to: triage first, and run only the submissions that read unlike the student's usual work. Institutions that genuinely want every submission screened can have their developers build batch checking against the REST API — that is an engineering project on their side, not a plugin.

Does TheChecker.AI store the text I paste from SpeedGrader?

No. Nothing you paste is stored, and the free demo requires no account. The text is analysed, the sentence-level result comes back in seconds, and that is the end of it — student writing does not sit on our servers afterwards.

Will the detector tell me which AI tool a student used?

It names the model the text most resembles, compared against more than 40 — GPT-4 and GPT-5, Claude 3 and 3.5, Gemini Ultra, Llama 3, Mistral and others. Treat that as a concrete observation to raise, not a forensic identification: many apps wrap the same underlying models, so a text that reads like GPT-5 could have come through any tool built on it.