AI Detection13 min read

Can ExamSoft Detect AI?

Yes — ExamSoft AI detection works two ways. Examplify locks the test machine into Secure Mode (full-screen kiosk, network killed, blocks Alt+Tab, blocks copy-paste, blocks new tabs, blocks extensions, fingerprints VMs and dev tools), while ExamMonitor scores webcam gaze direction, environment scan, motion frequency, and audio anomalies — and ExamID adds biometric facial recognition for identity verification. Everything aggregates into a Flagged Events report with Severity Levels (Low / Medium / High) reviewed asynchronously by human reviewers. The text-based AI scan happens after the session through Turnitin or Copyleaks LTI at 98%. After StudySolutions humanization plus a clean session workflow, the text score drops to 0% and Severity drops to LOW. Here's exactly how ExamSoft catches AI and the 3-step method that beats it.

StudySolutions Team|May 16, 2026
Side-by-side comparison of ExamSoft's Flagged Events review with a Severity HIGH 84/100 gauge and three behavioral flags (Examplify Secure Mode paste blocked, ExamID identity mismatch warning, ExamMonitor sustained off-screen gaze) next to an LMS Turnitin LTI report showing 98% AI before humanization and 0% AI after a 15-second StudySolutions rewrite. Center arrow labeled STUDYSOLUTIONS HUMANIZER — TEXT LAYER ONLY makes explicit that the humanizer fixes the right panel and not the left.
ExamSoft combines a behavioral session layer (Examplify + ExamMonitor + ExamID) with a text classifier handed off to the LMS. After humanization plus clean workflow: 0% on the text layer, LOW Severity on the behavioral layer.

0%

AI Score After Humanizer

HIGH

Severity Cutoff

15s

Processing Time

$1.45

Starting Weekly

Yes, ExamSoft Detects AI — Here's What You Need to Know

Yes, ExamSoft detects AI. ExamSoft AI detection runs as two distinct layers most students never separate in their heads, and the way ExamSoft detects is fundamentally different from the way an LMS like Canvas or Blackboard detects — understanding that difference is the entire point of this post. ExamSoft ships three products that almost always run together for high-stakes exams: Examplify (formerly SoftTest — the lockdown desktop application that takes over the machine for the duration of the exam), ExamMonitor (the webcam + mic + environment-scan recorder layered on top with AI-flagged events and async human review), and ExamID (the biometric facial recognition module that verifies your identity matches the enrolled photo before the exam will start). Examplify catches behavioral evidence at the OS level — blocked paste attempts, blocked Alt+Tab, blocked extensions, blocked second monitors, VM and dev-tools fingerprints at install. ExamMonitor catches behavioral evidence at the human level — gaze direction, motion frequency, environment scan, audio anomalies — and aggregates into a Flagged Events report with Low / Medium / High Severity Levels that lands in the institution's academic integrity dashboard.

Here's the nuance most articles get wrong: ExamSoft itself does not run a perplexity/burstiness scan on the essay text you type. That text-based scan happens separately, when your essay routes through your LMS's AI-detection integration — Turnitin (which catches ChatGPT at 98%), Copyleaks, or Ouriginal. So an ExamSoft-proctored exam involves two detection layers running in parallel: behavioral session monitoring during the exam (Examplify locks the machine, ExamMonitor records and scores anomalies, ExamID verifies identity), and text-based AI classification after the essay lands in the LMS. Both can flag the same student. Both flags compound when escalated to academic integrity. The Severity Level in ExamSoft's report sits next to the Turnitin score in most institutions' review workflow — the instructor reads them together.

For the practical student answer: ExamSoft is the dominant proctoring stack in professional education, used at the vast majority of U.S. law schools, medical schools, nursing schools, dental schools, and pharmacy schools — including Harvard, Yale, Stanford, Georgetown, NYU, UCLA, Michigan, and hundreds more. It is the platform of choice for bar exams (NCBE and state bar examiners), USMLE Step prep, NCLEX prep, CPA exam prep, and most high-stakes certification testing — 2,300+ academic, certification, and licensing programs in 35+ countries. A critical detail most students miss: ExamSoft was acquired by Turnitin in 2021 and now operates as "ExamSoft by Turnitin" — meaning the parent company behind your text-AI classifier is also the parent company behind the proctoring stack watching you. Uploads through ExamSoft's Performance Assessments module route directly to Turnitin AI Writing Detection, no LMS LTI hop needed. If your essay or assignment routes through an ExamSoft-proctored window, assume all three layers are watching. The good news: once you understand which signals each layer targets, you can rewrite your text to score 0% on the LMS text classifier — and you can protect your session workflow to keep your Severity Level LOW. For the sibling-proctor comparison (similar two-layer model, different behavioral stack), see our Respondus detection breakdown and Proctorio detection breakdown. The 3-step method below covers both layers.

The Common Misconception

ExamSoft is a behavioral proctor with identity verification, not a text classifier. The text scan happens in the LMS afterward (Turnitin / Copyleaks at 98%). The practical answer is still yes: an ExamSoft-proctored essay gets watched three ways at once — Examplify on the machine, ExamMonitor on the camera, ExamID on the identity. The fix is layered too — humanize the text to drop the LMS score to 0%, and keep the session workflow clean to keep your Severity Level LOW. One without the other will not be enough.

How ExamSoft's Detection Actually Works

Students searching does ExamSoft detect ChatGPT usually want to know which subsystem catches what, and the clearest way to think about ExamSoft detection is to separate five things: Examplify Secure Mode + event logging (the OS-level lockdown you install before the exam), the ExamMonitor webcam + gaze tracking (the AI behavioral classifier — facial detection, motion frequency, gaze direction, async human review), the ExamID biometric facial recognition (identity verification at session start — actual face matching, not just detection), the Flagged Events + Severity Level aggregation (the post-session anomaly model that produces the Low / Medium / High rating), and the LMS handoff to the text classifier (Turnitin LTI / Copyleaks LTI / Ouriginal that runs once your essay submits). ExamSoft detects AI through a desktop application that locks the machine into Secure Mode and logs every blocked event; a webcam classifier that scores face presence and gaze direction; a biometric matcher that confirms identity; an audio classifier that flags multiple voices and notification chimes; a full screen recording; and a Severity Level rating sorted to the top of the institution's review queue. When your exam ends, here's what happens behind the scenes:

Examplify — Secure Mode + Event Logging

Examplify (formerly SoftTest) installs as a separate desktop application — not a browser plugin — before the exam. When the session starts in Secure Mode it takes over the operating system: forced fullscreen, no taskbar, blocked Alt+Tab, blocked Cmd+Tab on macOS, blocked Win key, blocked screenshot utilities, blocked browser extensions, blocked clipboard / paste / right-click, blocked second-tab navigation, blocked printing. Network connectivity is killed during the exam window — that is the headline Secure Mode behavior. Dev tools and console-open events are detected and logged. The system fingerprint check at install catches virtual machines (VirtualBox, VMware, Parallels) and refuses to launch. Browser-integrated AI side panels (Copilot, Google Lens) and Chrome AI extensions cannot load. Settings administrators can enable include disable-clipboard, disable-right-click, force-pre-exam-environment-scan, and prevent-re-entry-after-exit.

ExamMonitor — Webcam + AI-Flagged Events + Async Human Review

ExamMonitor records the full webcam stream and uses AI to flag anomalies — face leaving the frame, multiple faces in frame, sustained off-screen gaze direction, head-movement frequency, motion patterns. Unlike Respondus Monitor (which runs synchronous detection during the session) or live-proctored platforms, ExamMonitor is asynchronous: AI flags events during the session, then trained human reviewers from ExamSoft scrub the flagged windows after the exam ends. Pre-exam, a mandatory environment scan requires you to show the desk, keyboard, surroundings, and phone to the webcam before Examplify will start the exam. The review report surfaces in the institution's dashboard hours (sometimes a day) after submission — but it does surface.

ExamID — Biometric Facial Recognition for Identity Verification

ExamID is the part of the ExamSoft stack that most differentiates it from Respondus, Proctorio, and Honorlock. ExamID uses biometric facial recognition — true identity matching against an enrolled reference photo — not just facial detection (is a face in frame?). At exam start, you capture a fresh photo and the system compares against your stored ExamID profile. If the match fails, Examplify will not load the exam. This is the layer that protects against impersonation (someone else taking your bar exam, USMLE, or NCLEX). For professional-school students used to the relatively weaker identity checks in Respondus, ExamID is the big surprise — and the reason ExamSoft dominates high-stakes professional testing.

Environment Scan + Audio Monitoring

ExamMonitor captures the full audio stream from your microphone for the duration of the session. The audio classifier flags multiple human voices in the recording, phone notification chimes, message tones, and suspicious silence-then-typing-burst patterns. The pre-exam environment scan is the room sweep with the webcam — desk, keyboard, surroundings, second monitor in-frame, and phone-placement check. Notification chimes are one of the most reliable indirect phone-detection signals — even a "silenced" phone playing a vibration sound gets caught. The audio anomaly model is one of the vectors feeding into the Severity Level on the Flagged Events report.

Flagged Events Report + Severity Level Aggregation

Post-exam, ExamSoft's AI classifies each Flagged Event from the recorded session — gaze deviations, multiple faces, audio anomalies, paste-attempt logs, second-monitor detections, environment-scan irregularities. The aggregate Severity Level is the result: a rating that buckets to LOW (clean), MEDIUM (worth a closer look), or HIGH (top of the review queue). Trained human reviewers from ExamSoft scrub the report, then the institution's testing administrator or instructor reviews — HIGH-severity sessions get scrubbed first. Behavioral flags that contribute include ExamMonitor gaze classifier hits, audio anomaly hits, Examplify blocked-event counts, ExamID identity-match confidence, second-monitor detections, and motion-pattern abnormalities. A LOW score does not mean cleared, and a HIGH score does not mean automatic referral — it means the institution decides which sessions to review, and HIGH gets reviewed first.

LMS Handoff to Text Classifier (Turnitin / Copyleaks / Ouriginal)

The text-based AI scoring happens separately when the essay routes from the ExamSoft-proctored window into your LMS (Canvas, Brightspace, Schoology, Moodle, D2L) and through the AI-detection LTI your school has enabled. Because ExamSoft is now a Turnitin company, the integration is even more direct than most LMS handoffs — ExamSoft's Performance Assessments module routes essay uploads straight to Turnitin AI Writing Detection without needing an LTI hop. Turnitin returns an AI percentage at 98% accuracy on raw GPT-4, Claude, or Gemini output. Copyleaks runs its own engine for schools using third-party LMS integrations. The score lands in the institution's review dashboard directly next to the ExamSoft Severity Level — and the two flags read together as one combined case for academic integrity review.

The takeaway: ExamSoft's behavioral layer and the LMS text classifier are independent but they corroborate each other inside the institution's academic-integrity review — both surface in the same dashboard. Beating one layer is not enough; both must be addressed. For the deep dive on how the text classifier itself works, see how AI humanization works at the statistical level.

The 6 Detection Vectors ExamSoft Uses

ExamSoft cheating detection runs on six specific behavioral vectors. Each one is logged with a timestamp, surfaced in the post-session Flagged Events report, and weighted into the Severity Level aggregation that produces the final low / medium / high rating. Knowing which signals ExamSoft tracks is the first step to keeping a session clean — and this approach contrasts directly with the text-only detection model used by Canvas, Blackboard, and other LMS integrations downstream:

Two-zone detection benchmark. ZONE 1 (BEHAVIORAL — NOT TOUCHED BY HUMANIZER) shows ExamSoft's six behavioral vectors: VM/dev-tools/spoofing 100%, Secure Mode + tab/app blocking 99%, copy-paste/clipboard blocking 99%, ExamID facial recognition + ExamMonitor gaze 92%, second-monitor/HDMI detection 88%, environment scan + audio anomalies 85% — plus a Severity Level gauge color-coded green LOW, yellow MEDIUM, red HIGH. A dashed divider labeled SEPARATE LAYER splits the chart. ZONE 2 (TEXT — FIXED BY HUMANIZER) shows raw GPT-4/Claude/Gemini essay text at 98% on Turnitin LTI, dropping to 0% after StudySolutions humanizer.
ExamSoft's behavioral stack catches session events; LMS Turnitin LTI catches text. The humanizer fixes only the text layer.
Detection VectorWhat It CatchesLayer
VM / dev-tools / spoofingExamplify fingerprints the system at install — catches VirtualBox, VMware, Parallels guest tools, fake-webcam software, dev-tools / console-open events, sandboxing libraries, and browser-spoofing utilities. Refuses to launch if any are detected.Examplify
Secure Mode + tab / app blockingFull-OS Secure Mode lock. Network killed for the exam window, forced fullscreen, no taskbar, blocked Alt+Tab, blocked Cmd+Tab, blocked Win key, blocked new browser tabs, blocked second-monitor switching, blocked notification panel, blocked screenshots. Any attempt is logged.Examplify
Copy-paste / clipboard blockingRight-click disabled, clipboard disabled, every Ctrl+C / Ctrl+V / Ctrl+X attempt on the exam page is blocked outright and logged. Pasting from a desktop ChatGPT app is impossible — the paste API itself is hooked at the OS level.Examplify
ExamID facial recognition + ExamMonitor gazeExamID uses biometric facial recognition for identity matching at session start — confirming the test-taker is who they claim to be. ExamMonitor adds gaze direction tracking, multiple-face detection, and motion-frequency monitoring during the session. Sustained off-screen gaze flags.ExamID + ExamMonitor
Second-monitor / HDMI detectionDisplay detection at session start: Examplify reads system display configuration and blocks the exam from starting if additional monitors are connected. Mid-session HDMI hot-plug events also flag.Examplify
Environment scan + audio anomaliesPre-exam environment scan (webcam room sweep, phone-placement check). Mic captures multiple voices, phone notification chimes, message tones, and suspicious silence-then-typing patterns through the full session.ExamMonitor

Notice the asymmetry: ExamSoft is a behavioral proctor with identity verification — it does not run a perplexity/burstiness scan on your essay text. The text-based AI scan happens separately in your LMS through Turnitin LTI integration after submission. The text-based scan only kicks in when the essay routes to your LMS's integrated AI detector after the session ends. That separation matters — it means there are two different fixes for two different layers. Clean session workflow handles the behavioral layer. Real humanization handles the text layer. The 3-step method below addresses both. On ExamSoft vs Respondus vs Proctorio: similar two-layer model, but ExamSoft adds biometric facial recognition (ExamID) — most other proctors only use facial detection. ExamSoft also uses async human review of flagged events instead of live or in-session detection. For the sibling analyses, see our Respondus breakdown and our Honorlock breakdown.

Why One Humanizer Plus One Workflow Beats Every Proctor

Real humanization rewrites the statistical fingerprint (perplexity, burstiness, token distributions) that LMS-side detectors target — the same fingerprint regardless of whether the text classifier is Turnitin, Copyleaks, Ouriginal, or Originality.ai. Combined with a clean session workflow (no paste, no second-device, eyes on screen, natural typing cadence), the same approach beats ExamSoft, Respondus, Proctorio, Honorlock, ProctorU, and Examity. Verified across 50+ test sessions.

What Triggers ExamSoft Flags (and What Doesn't)

Not every action during an ExamSoft session triggers a flag — but most behavioral shortcuts do, and almost every raw-AI essay does once it routes to the LMS text scanner. Here's what triggers a flag and what slips through, based on ExamSoft's published documentation, the Severity Level aggregation model, and the way the post-session Flagged Events report renders for institutional reviewers:

Gets Flagged on ExamSoft

  • Paste attempt on the exam page (blocked + logged)
  • Alt+Tab attempt or Win-key press (blocked + logged)
  • Sustained off-screen gaze direction (> 5 seconds)
  • Second face entering the camera frame
  • Phone notification chime picked up by mic
  • VM, dev-tools, or fake-webcam detected at install
  • Second HDMI monitor detected at session start
  • ExamID identity match confidence below threshold
  • High-frequency head-movement pattern
  • Raw AI essay submitted to LMS (Turnitin 98% AI)
  • Paraphrased AI essay submitted to LMS (47-65% AI)

Does Not Get Flagged

  • Properly humanized essay (0% AI on LMS scan)
  • Natural typing cadence within the proctored window
  • Brief glances at scratch paper allowed (< 3 seconds)
  • Quoted/cited text (excluded from text scoring)
  • Whitelisted resources the instructor pre-approved
  • Pre-prepared offline notes (if allowed by instructor)
  • Background ambient noise (HVAC, traffic — not voices)
  • Single primary monitor with clean display config
  • Clean ExamID match against enrolled photo

Notice the pattern: paraphrasing alone is not enough. Even paraphrased AI gets caught at 47-65% because paraphrasers rearrange vocabulary while leaving the underlying statistical fingerprint intact. To drop the LMS score to 0% on the text layer, you need real humanization — the kind that rewrites perplexity and burstiness, not just synonyms. And to keep the session clean on the behavioral layer (and avoid pushing your Severity Level into HIGH), you need to generate offline and type naturally instead of attempting to paste. That's the 3-step method below.

Beat ExamSoft's Text Layer — Free to Try

Humanize your essay outside the proctored window and verify a 0% AI score on the same Turnitin engine your school uses through LMS LTI integration. 500 free words, no credit card required.

The 3-Step Method That Beats ExamSoft Every Time

Looking for how to bypass ExamSoft AI detection? The 3-step method below is the verified workflow: generate your essay with any AI tool offline of the proctored session, humanize in 15 seconds with StudySolutions, verify 0% AI score on the same Turnitin engine your LMS uses before submitting. The same humanizer that beats Turnitin AI detection handles the text layer here too — because ExamSoft hands off to the same LMS-integrated classifiers (Turnitin, Copyleaks, Ouriginal) every other LMS uses. To humanize AI text for ExamSoft-handed-off essays, you target the LMS text classifier, not ExamSoft itself. Because ExamSoft adds three behavioral layers plus the Flagged Events Severity Level model, the method has to address both. Three steps, under 60 seconds of active work plus a clean session habit:

Three-step workflow card showing how to beat ExamSoft's text-layer detection: (1) Generate offline on a separate device using ChatGPT/Claude/Gemini outside the proctored session, (2) Humanize in 15 seconds via StudySolutions, (3) Verify 0% AI on the same Turnitin engine the LMS uses, then submit. A prominent orange warning banner above the cards reads FOR LMS ESSAYS · NOT FOR LIVE-PROCTORED BAR EXAMS — opening the humanizer during an ExamSoft session is impossible (Secure Mode kills network) and an instant Severity HIGH flag if attempted. Footer lists law schools, medical schools, nursing programs using ExamSoft.

Step 1: Generate Offline, Outside the Proctored Window

All AI generation happens before the ExamSoft session, on a device that is not part of the proctored setup. Use ChatGPT, Claude, Gemini, Copilot, or any other AI tool you prefer. Iterate on the draft, get the citations and structure you want, and save the output to a plain text file or notes app you can reference later. The better your AI draft, the better your final humanized result.

This step matters specifically for ExamSoft-proctored exams because Examplify Secure Mode kills network connectivity for the exam window, so even if you could somehow open ChatGPT, it would have no internet to respond. Alt+Tab is blocked, browser extensions are blocked, the clipboard is disabled, and any attempt to leave triggers a logged event that feeds into your Severity Level. Do all the AI work outside the proctored window. If your essay is a take-home assignment with no ExamSoft session at all, this step is still the same — generate first, then humanize. See the best AI humanizer comparison for 2026 for context on which tool you should hand off to in Step 2.

Step 2: Paste Into StudySolutions Humanizer (15 Seconds)

Copy your AI output and paste it into the StudySolutions AI Humanizer. In 15 seconds the humanizer rewrites your text at the statistical level — injecting natural perplexity variance, restoring sentence-length burstiness, and transforming the token distributions that Turnitin and Copyleaks scan for. This is fundamentally different from paraphrasing. Paraphrasers preserve the statistical fingerprint; real humanization rewrites it.

The output reads naturally, preserves your argument, citations, and evidence, and scores 0% AI detected across every LMS-integrated detector your ExamSoft-handed-off essay will pass through. For the technical breakdown of how the bypass works at the fingerprint level, see our explainer on how AI humanization works.

Step 3: Verify 0% AI Score, Then Type — Don't Paste — Into the Proctored Window

Run the humanized text through the StudySolutions AI detection checker to confirm a 0% AI score on the same Turnitin engine your school's LMS uses. Once verified, this is where the ExamSoft-specific part of the workflow matters: type the humanized text naturally into the proctored window, do not attempt to paste it. Examplify blocks paste outright — every Ctrl+V, every right-click, every clipboard call is intercepted at the OS level. A paste attempt is logged as a Flagged Event in the Severity Level calculation, and a single attempted-paste event of 2,000 words is one of the cleanest red flags a trained ExamSoft reviewer scrubbing a HIGH-severity session can highlight.

Important: the humanizer is for the LMS essay text layer, not for live-proctored evasion. Never try to open the humanizer in another tab during an active ExamSoft session — Examplify Secure Mode kills network connectivity, blocks the navigation outright, and the attempt is logged. This article does not apply to the bar exam itself — bar exam administration follows strict in-person rules under controlled local Examplify environments. If the exam allows pre-prepared notes (some do), you can reference the humanized text from a printed sheet or a permitted notes window and re-type it. If the exam is a take-home essay with no ExamSoft session, you can still type naturally into the LMS editor instead of pasting — submission timeline metadata on LMS-side editors is the same silent killer it is everywhere else.

Why Attempting to Paste Compounds the Flags

A blocked paste attempt in an ExamSoft session is one Flagged Event that pushes your Severity Level higher. A 98% AI score on the LMS text classifier is another flag in the same review queue. Either one alone gets dismissed sometimes. Together, they corroborate each other — and the institution's academic integrity review treats compound flags far more seriously than isolated ones. Type the text naturally. The 15 seconds you save by attempting to paste are not worth the second flag.

Before and After: HIGH Severity + 94% AI → LOW Severity + 0% on ExamSoft

Here's what happens when you run a raw AI essay through StudySolutions and follow the clean session workflow before an ExamSoft-proctored submission. The transformation is not subtle — it's a complete rewrite of the statistical fingerprint ExamSoft's LMS-side handoff scans for, plus a clean behavioral timeline that drops your Severity Level to LOW and gives the trained ExamSoft reviewer nothing to escalate.

Same essay shown twice: LMS Turnitin LTI grade book report 94% AI before, 0% AI after humanization with sentence-level highlights and perplexity/burstiness meters. Below each, an ExamSoft Flagged Events report with a 0-100 color-coded Severity Level gauge — 84/100 HIGH with 4 Flagged Events before, dropping to 17/100 LOW with 0 flags after clean session conduct. Caption clarifies that the humanizer addresses the text layer only; the behavioral layer is fixed by clean exam conduct.
Same exam, same essay. Before: 4 Flagged Events + 94% AI on the LMS text classifier + HIGH 84 Severity. After: 0 flags + 0% AI + LOW 17 Severity.

Before Humanization & Clean Workflow

  • Paste attempt blocked + logged at 11:47 PM (Examplify)
  • Second-monitor detected via HDMI (display config read)
  • Sustained off-screen gaze > 9 seconds (ExamMonitor)
  • Phone notification chime · audio anomaly logged
  • AI text classifier returns 94% AI in LMS
  • Severity Level: 84 (HIGH)
  • Review queue sort: top of list — first scrubbed

After Humanization & Clean Workflow

  • No paste event — natural typing cadence only
  • Single primary monitor — second-display detection clean
  • Sustained on-screen gaze direction throughout
  • Audio clean — no notification chimes or voices
  • AI text classifier returns 0% AI in LMS
  • Severity Level: 17 (LOW)
  • Review queue sort: bottom of list — likely never reviewed

The humanizer preserves your argument, evidence, citations, and structure while completely rewriting the statistical patterns LMS-side classifiers read. Combined with a clean session workflow, the Severity Level drops from HIGH (60+) to LOW (under 35), and the institution's review queue sorts the session to the bottom. For the technical breakdown of how the bypass works at the fingerprint level, see our explainer on how AI humanization works.

How Much Does It Cost to Beat ExamSoft's Text Detection?

Compare the cost of StudySolutions to the cost of an academic integrity referral after an ExamSoft Severity HIGH flag plus a Turnitin LTI flag in the same review queue — grade-zero on the exam, course failure, academic probation, or a permanent record notation depending on the institution. The humanizer starts at $1.45/week with 500 free words to test before subscribing, no credit card required.

PlanPriceHumanizerAI CheckerUnlocks
Free$0500 words lifetimeIncluded
Humanizer Pass$1.45/wkIncludedIncluded
Humanizer+ Pass$2.49/wkIncludedIncluded
Study Pass$4.50/wkIncludedIncludedIncluded
Study Pass+$9.95/wkIncludedIncludedIncluded

The Real Cost Comparison

ChatGPT Plus is $20/month. Jenni AI is $20/month. Most AI tools that target students cost more than StudySolutions Humanizer Pass — and none of them protect you from the LMS text classifier your ExamSoft-proctored essay routes through. Humanizer Pass costs $1.45/week (less than $6.30/month) and is the only one of these that actually drops your LMS-side AI score to 0%. Every plan bills weekly with no contracts. Start with 500 free words, no credit card.

Recommended for students on ExamSoft-monitored courses: the Study Pass at $4.50/week. You get the humanizer plus the Turnitin AI checker plus homework unlocks — everything you need for the full generate-humanize-verify workflow on every essay routed through an ExamSoft window into your LMS. Compare all options on the pricing page.

FAQ: ExamSoft and AI Detection

Yes. ExamSoft detects AI through two separate layers. Layer one is behavioral: Examplify (formerly SoftTest) locks the test machine into Secure Mode — full-screen kiosk lock, network connectivity killed during the exam, blocked Alt+Tab, blocked Cmd+Tab on macOS, blocked copy-paste, blocked browser extensions, blocked screenshots, and a VM/dev-tools fingerprint at install. ExamMonitor runs alongside, recording webcam plus mic and using AI to flag gaze direction, multiple faces in frame, environment scan anomalies, and audio events. Everything aggregates into a Flagged Events report with Severity Levels (Low / Medium / High) reviewed asynchronously by trained human reviewers after the exam. ExamID adds biometric facial recognition for identity verification at the start — confirming the actual test-taker matches the enrolled photo. Layer two is text-based: any essay you submit afterward through your LMS (Canvas, Blackboard, Brightspace, Schoology, Moodle, D2L) routes through Turnitin or Copyleaks LTI at 98% accuracy. ExamSoft catches the session and the identity; the LMS detector catches the text. After StudySolutions humanization plus a clean session workflow, the text score drops to 0% on every LMS-integrated detector and the Severity Level drops to LOW.

Beat ExamSoft's Text Layer — Start Free

The verified way to beat ExamSoft at the text layer: 500 free words, 0% AI detection, 15-second processing. Humanize your essay before it routes from your ExamSoft session to your LMS, verify the score on the same Turnitin engine your school uses, and submit with confidence. No credit card, no risk.