How to Integrate ProctorSafe in Under One Hour: A Technical Walkthrough

What this guide covers

This is a practical integration guide for technical teams deploying ProctorSafe with an LMS (Learning Management System). By the end, you'll have:

• The SDK running in an exam session
• A session started and its ID stored against your own exam record
• Trust score events flowing to the review dashboard

Estimated time: under one hour. No prior experience with proctoring systems required.

Prerequisites

Before you start, you'll need:

• A ProctorSafe account with an active tenant slug
• Access to the exam page's template so you can add a script tag (an LMS content editor, theme file, or custom page — see Integrating with Moodle, Canvas, and Blackboard for LMS-specific placement)
• A development or staging environment for initial testing

Step 1: Add the SDK to your exam page

The ProctorSafe SDK is loaded with a single script tag. Add it to the HTML template your LMS uses for proctored exam pages:

<script src="https://your-deployment.example.com/sdk/proctor.iife.js"></script>

The SDK auto-loads its own dependencies (TensorFlow.js, the face-detection model, and its WASM module) the first time it runs. It runs entirely client-side — no server-side components to deploy.

Step 2: Start a session

ProctorSafe does not authenticate the candidate — that stays your responsibility, exactly as it is today for the rest of your exam flow. Once your page knows who is sitting the exam, start the proctoring session:

const sessionId = await Proctor.start(
  {
    tenantName: 'your-tenant-slug',
    applicationReference: 'exam-platform-2024',
    settings: {
      hudMode: 'full',
    },
  },
  (event) => {
    console.log('Proctor event:', event);
  }
);

// Store this against your own exam/candidate record
console.log('Session started with ID:', sessionId);

tenantName and applicationReference are required; everything else is optional. There is no launch handshake to configure on either side — the SDK connects directly from the candidate's browser.

On the roadmap: LTI 1.3 / LTI Advantage platform-to-tool launches are not available today. If your LMS supports LTI, that's still the right place to authenticate the candidate before they reach this page — ProctorSafe just isn't the LTI tool itself yet.

Step 3: Define your exam policy

Detection thresholds — identity-check sensitivity, gaze, audio, clipboard and network monitoring — are configured by your ProctorSafe administrator as a named proctoring profile, not passed from your page:

await Proctor.start({
  tenantName: 'your-tenant-slug',
  applicationReference: 'exam-platform-2024',
  proctoringProfile: 'strict-identity-exam',
  settings: { hudMode: 'full' },
}, onEvent);

If you omit proctoringProfile, the session uses your tenant's baseline profile.

Key things a profile controls:

• Trust score threshold: sessions are scored on a 0–100 integrity budget; your administrator sets which score ranges route to spot-check vs. investigate
• Which detection signals are active: focus loss, tab switches, devtools, gaze, audio
• Data retention: how long event logs are kept, set per tenant

settings on your page still controls presentation — hudMode, showLoadingProgress, enableOfflineSync — but not detection thresholds.

Step 4: Test in staging

Before deploying to students:

1. Create a test exam page pointed at your own staging deployment
2. Open the exam as a student — use a different browser or incognito window
3. Trigger a few flags deliberately — open a new tab, switch applications — to see how events appear in the dashboard
4. Check the event log — verify that only event metadata is present, no video or biometric data

Step 5: Deploy to production

When you're satisfied with the staging test:

1. Point the script tag at your production deployment
2. Enable proctoring on the live exam page
3. Run a small pilot first — 5–10 students — before a full cohort
4. Monitor the first session reviews in real time and adjust thresholds if needed

What "under one hour" actually means

The one-hour estimate assumes:

• You already have a page that authenticates the candidate before the exam starts
• You're testing in a staging environment with non-production data
• Your ProctorSafe administrator is available to set up the proctoring profile

The SDK integration itself — script tag, Proctor.start(), event handling — is genuinely quick. Most of the hour goes to defining the proctoring profile and testing it, not to the code.

What's included in the SDK

Next steps

Once you've completed the integration, explore:

• Threshold calibration — adjusting flag sensitivity based on your student population
• Review workflow setup — configuring who receives flagged session alerts and how
• Reporting — aggregate integrity analytics across your exam sessions
• If you're migrating from another proctoring platform, see How to Replace Your Proctoring Platform Without Breaking Your LMS for the full rollout checklist

Questions during integration? The docs at proctorsafe.eu/docs cover each step in detail, or reach out to the integration team.