No, Canvas does not track individual keystrokes, typing speed, or what you typed and then deleted. Its public Quiz Submission Events API documents only five event types — session_started, question_answered, question_flagged, page_blurred, and page_focused — and none of them carry keystroke-level data. Canvas records final submitted answers and event timestamps, not how you typed.
This is one of the more common cheating-paranoia questions students ask, and the honest answer is that Canvas itself is far less sophisticated than the rumors suggest. The complication is that proctoring tools layered on top of Canvas (Honorlock, Proctorio, Respondus LockDown Browser Monitor) do record video of your screen and webcam — and your typing is visible in that recording. But those are separate vendors, not Canvas. Below we walk through exactly what Canvas does and does not capture about your typing, what the published API includes, and where the line is between Canvas and the proctoring layer.
Short Answer
- Individual keystrokes: Not tracked. Canvas's quiz JavaScript does not attach
keydownorkeyuplisteners that report to the server. - Typing speed / WPM: Not tracked. There's no API endpoint that records typing cadence.
- Drafts and deletions: Not tracked. Only your final submitted answer reaches Canvas.
- Copy and paste: Not tracked by Canvas itself. The textarea is a standard browser input with no clipboard instrumentation. Plagiarism tools like Turnitin compare your final text to a corpus, not your input behaviour.
- Time-per-question: Inferred indirectly. Canvas records the timestamp when each answer is saved, so the gap between two save events is observable — but that's response time, not typing speed.
- Proctoring tools (Honorlock, Proctorio, Respondus Monitor): Record video of your screen and webcam. Typing is visible in that recording. These are separate from Canvas.
What Canvas actually records about your typing
The exhaustive list of what Classic Quizzes captures during a quiz is published in Instructure's Quiz Submission Events API. The event types are:
session_started— quiz openedquestion_answered— an answer was saved to the server, with the answer payloadquestion_flagged— you marked a question for reviewpage_blurred— the quiz tab lost focuspage_focused— the quiz tab regained focus
Look at what's not on that list: no keypress, keydown, typing_started, typing_stopped, character_count, backspace, paste, clipboard_read. Canvas does not capture any of those because the API doesn't define them. The data Canvas can record is constrained by what its own JavaScript reports back — and the JavaScript reports the five event types listed above.
The question_answered event carries the answer payload, but only the final value at the moment the answer was saved. Canvas Classic Quizzes auto-saves periodically (typically every 30 seconds or on field-blur), so multiple question_answered events can fire for the same question as the answer evolves — but each one records the answer as it stands at that save tick, not the keystroke-level history that led to it. If you typed "Pari", then "Paris", and submitted "Paris", what reaches the server is "Pari" then "Paris" — two save points, not 6 keystrokes.
For the full breakdown of what Canvas captures during a quiz, see the quiz logs explainer and the broader what Canvas tracks deep dive. The short answer for the keystroke question: not at this layer of granularity.
Why Canvas doesn't capture keystrokes
Three reasons, and they're all structural.
1. It would be illegal in many jurisdictions. Capturing every keystroke a student types is the technical equivalent of keylogging, which is regulated under wiretapping and electronic communication privacy laws in many US states (California, Illinois, Texas) and most of the EU under GDPR. Canvas is not a piece of monitoring software — it's an LMS — and Instructure is not licensed to operate as one. Building keylogging into a product used by 30 million students would create immediate regulatory exposure that no one at Instructure has any reason to take on.
2. It would be enormously expensive at Canvas's scale. Even if it were legal, storing keystroke-level data for every student in every quiz worldwide would produce a data volume that's orders of magnitude larger than what Canvas currently records. The quiz log table already holds tens of billions of question_answered rows. Multiplying that by 20–30 (average characters per answer) would balloon storage costs without adding educational value.
3. It wouldn't actually catch cheaters. The cheating patterns that keystroke logging would theoretically detect — a sudden block of pasted text, an unnaturally fast burst of typing — can be detected post-hoc by plagiarism tools (Turnitin Originality, Copyleaks) that analyze the output rather than the typing process. Schools already have those tools, they've integrated with Canvas via LTI for years, and they work without keystroke logging. There's no functional gap that keystroke capture would fill.
When proctoring tools change the answer
Everything above describes Canvas LMS itself. When your exam launches a separate proctoring tool — the kind that shows a "this exam requires X" prompt before the quiz starts — the rules change. Three common ones:
Respondus LockDown Browser Monitor: Replaces your browser with a locked version that disables tab switching and runs a screen-recording session. Your typing is visible in the screen recording. The recording is uploaded to Respondus's servers for review, optionally with AI-flagged moments.
Honorlock: Browser extension plus webcam + screen capture. Records the full exam session including your typing. The recording is reviewed by AI and optionally by human proctors.
Proctorio: Chrome extension. Records webcam, microphone, and screen. Same model as Honorlock. Like Honorlock, the keystroke-level data is in the video, not in a structured log — reviewers see what you typed by watching the screen recording.
None of these tools sit inside Canvas. They integrate via LTI (Learning Tools Interoperability) and run their own session alongside Canvas's quiz. If your exam doesn't require one (no special launcher, no "you're being recorded" warning), you're in pure-Canvas territory and the keystroke answer remains: not tracked.
For the related question on what proctoring captures versus Canvas, see our post on whether Canvas can detect screen sharing — same Canvas-versus-proctor distinction applies there.
Does Canvas track copy and paste?
Canvas does not have a paste event in its quiz logging vocabulary. The textarea you type answers into is a standard HTML <textarea> element — clipboard events are not instrumented. Pasting a block of text into an essay question is invisible to Canvas at the event-stream level.
What can flag pasted text is Turnitin or another plagiarism integration. Those tools analyze the submitted text for stylistic uniformity, AI signature patterns, or matches to a corpus. They don't watch you paste; they read what you submitted and compare it. So copy-paste is not tracked as an event, but the result of copy-paste — an unusual amount of pre-formatted, source-matching text — can be flagged later by the plagiarism layer.
What Canvas can infer from timestamps
The one piece of behavioural data Canvas does derive is response time. Every question_answered event has a timestamp. Subtracting timestamps gives you the gap between saves — which is approximately how long you spent on a question.
Instructors can see this in the quiz log interface: a column showing time spent per question. The signal is crude (it's based on save-event spacing, not keystroke timing), and it can be confounded by simple things like a student leaving the quiz open while making a sandwich. But it's the closest Canvas itself gets to inferring anything about typing behaviour. The gap between save events is not your keystroke speed; it's your response time, which includes thinking, reading, scrolling, looking up your notes, and yes, typing — all bundled into one number.
If you want to take a Canvas quiz without leaving these data points behind — the focus events more than the typing data — see our Canvas hack guide. The focus tracking (which is what actually generates flags in your quiz log) is what Canvas Ninja's Privacy Guard blocks at the browser level.
Canvas doesn't track keystrokes. It tracks focus.
If your exam concern is what's in the quiz log, the events that matter are page_blurred and page_focused — not what you typed. Canvas Ninja's Privacy Guard blocks those events at the browser level.
Frequently Asked Questions
- Does Canvas track keystrokes?
- No. Canvas LMS does not log individual key presses, typing speed, or backspace usage. Its public Quiz Submission Events API documents five event types, none of which include keystroke data. Canvas records final answers and timestamps, not how you produced them.
- Does Canvas track typing speed?
- No. Canvas does not measure WPM, key-hold duration, or pause patterns. It does timestamp answer saves, so it can infer how long you spent on a question — but that's response time, not typing speed.
- Can Canvas see what I typed and then deleted?
- No. Only your final submitted answer is captured. Drafts, intermediate versions, and deletions stay in the browser.
- Do proctoring tools track keystrokes?
- Indirectly. Tools like Honorlock, Proctorio, and Respondus Monitor record video of your screen, so your typing is visible in the recording. They don't store keystrokes as structured data, but reviewers can see your typing by watching the recording.
- Does Canvas detect copy and paste in answers?
- Canvas itself does not flag clipboard events. The textarea has no paste instrumentation. Plagiarism tools (Turnitin Originality, Copyleaks) analyze your final submitted text against a corpus — they detect copied content by comparing the output, not by watching you paste it.