canonical: https://jentic.com/apis/proctorexam.com/proctorexam

# ProctorExam API

The ProctorExam API enables programmatic management of online exam proctoring across 44 endpoints, covering exam creation, student session management, proctor assignment, identity verification, document attachments, and LTI integration. It supports the full exam lifecycle from scheduling through identity verification and proctored session monitoring, with institute and identity provider management for multi-tenant deployments.

## For AI agents

Create and manage proctored online exams, assign proctors to student sessions, verify student identities, and handle exam documents and attachments for remote assessment.

## Scope

Does not handle course management, grading rubrics, or learning content delivery - use for online exam proctoring and identity verification during assessments only.

## Capabilities

- Create and configure proctored exams with scheduling, duration, and access control settings
- Manage student exam sessions including start, end, and proctor assignment workflows
- Verify student identities through ID card and face photo capture during exam sessions
- Attach exam documents and supplementary materials to exams for student access
- Generate and download bulk exam document archives for offline review
- Configure LTI resource links for integration with learning management systems
- Manage institute accounts and identity providers for multi-tenant proctoring deployments

## Use cases

### Remote Exam Administration

Administer proctored exams for remote students by creating exam configurations, enrolling students into sessions, and assigning proctors for live monitoring. The ProctorExam API handles the full session lifecycle from creation through completion, with endpoints for sending exam invitation emails, tracking session status, and recording start and end times. Supports bulk exam creation for large cohorts.

Example prompt: Create an exam via POST /exams with title, duration, and start time, then trigger invitation emails to enrolled students using POST `/exams/{id}/send_emails`

### Student Identity Verification

Capture and verify student identities during exam sessions using ID card photos and face captures. The API provides endpoints to retrieve the captured identity documents for manual or automated review, enabling institutions to confirm that the exam-taker matches the enrolled student. This supports compliance with academic integrity policies.

Example prompt: Retrieve the ID card photo from GET `/student_sessions/{id}/id_card` and the face photo from GET `/student_sessions/{id}/face_photo` for a completed exam session to verify student identity

### LMS Integration via LTI

Connect ProctorExam with learning management systems through LTI resource links. The API allows agents to create and manage LTI resources that map exams to LMS course activities, enabling students to launch proctored exams directly from their LMS. Identity providers can be configured per institute for single sign-on access.

Example prompt: Create an LTI resource via POST /lti_resources linking an exam ID to an LMS course activity, then verify the resource is accessible via GET `/lti_resources/{id}`

### AI Agent Proctoring Automation

Enable AI agents to manage online exam proctoring workflows through Jentic. Agents can create exams, monitor session states, assign proctors based on availability, and retrieve identity verification data without hardcoding API paths. This supports automated exam administration for large-scale online education programs.

Example prompt: Search Jentic for 'create a proctored online exam', load the operation schema for POST /exams, and execute with exam title, date, and duration to schedule a new proctored assessment

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/exams` | Create a new proctored exam |
| GET | `/exams/{exam_id}/student_sessions` | List all student sessions for an exam |
| POST | `/student_sessions/{id}/assign_proctor` | Assign a proctor to a student session |
| POST | `/student_sessions/{id}/end_exam` | End a student's exam session |
| GET | `/student_sessions/{id}/id_card` | Get student ID card verification photo |
| GET | `/student_sessions/{id}/face_photo` | Get student face verification photo |
| POST | `/exams/{id}/send_emails` | Send exam invitation emails to students |
| POST | `/lti_resources` | Create an LTI resource link |

## Key resources

- **Exams** — Proctored exam configurations with scheduling, co-manager, and document management
- **Student Sessions** — Individual exam session instances with proctor assignment and identity verification
- **Attachments** — Files attached to exams for student reference during sessions
- **Documents** — Exam documents with bulk archive generation and download
- **LTI Resources** — Learning Tools Interoperability links for LMS integration
- **Institutes** — Organization accounts for multi-tenant proctoring management

## Why Jentic

- **Setup:** Wiring the ProctorExam API by hand means setting its token header, targeting app.proctorexam.com/api/v3, and mapping exams and student sessions yourself. Through Jentic you install once, import ProctorExam from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** ProctorExam puts the exam and session id in the URL path (`/exams/{exam_id}/student_sessions`, `/student_sessions/{id}/assign_proctor`), so a rule can pin your agent to a specific exam or session. You choose the operations it may call, so a write like ending an exam is not included unless you add it.
- **Credential handling:** Your ProctorExam API token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create a proctored online exam' or 'assign a proctor to a session', and Jentic returns the matching ProctorExam operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Zoom Meetings API** — Video conferencing for live proctoring sessions and oral examinations
- **Notion API** — Documentation and knowledge management for exam preparation materials
- **ClickUp API** — Task and project management for coordinating exam administration workflows

## FAQ

### What authentication does the ProctorExam API use?

The ProctorExam API uses token-based authentication via an API key passed in the request header. Tokens are issued per institute account. Through Jentic, these tokens are stored encrypted in the credential vault and injected automatically - agents never handle raw authentication tokens directly.

### Can I create and schedule proctored exams with the ProctorExam API?

Yes. POST to /exams creates a new exam with configurable title, scheduled date, duration, and access settings. You can then send invitation emails to students via POST `/exams/{id}/send_emails` and manage exam documents through the `/exams/{exam_id}/documents` endpoints.

### What are the rate limits for the ProctorExam API?

ProctorExam applies per-account rate limits based on your subscription tier. The API returns standard HTTP 429 responses when limits are exceeded. For bulk exam creation or large student cohorts, batch operations through the document archive endpoints help minimize individual requests.

### How do I assign a proctor to a student session through Jentic?

Search Jentic for 'assign proctor to exam session', load the operation schema for POST `/student_sessions/{id}/assign_proctor`, and execute with the session ID and proctor identifier. You can verify the assignment with GET `/student_sessions/{id}/assigned_proctor.` Install with pip install jentic and run it through Jentic One, the self-hosted execution layer.

### Does the ProctorExam API support identity verification?

Yes. During exam sessions, students capture ID card photos and face photos. The API provides GET `/student_sessions/{id}/id_card` and GET `/student_sessions/{id}/face_photo` to retrieve these images for verification. Institutions can compare the captured face against the ID document to confirm student identity.

### Can I integrate ProctorExam with a learning management system?

Yes. The /lti_resources endpoints allow you to create LTI (Learning Tools Interoperability) resource links that connect exams to LMS course activities. Students can launch proctored sessions directly from their LMS. Identity providers can be configured per institute for SSO access via /identity_providers.

### Can I limit what my agent is allowed to do with the ProctorExam API?

Yes. Because you run Jentic One yourself, your own rules decide which ProctorExam operations and credentials the agent may use. You pick the exact operations it can call, so a write like ending a session with POST `/student_sessions/{id}/end_exam` stays out of reach unless you add it, while a read like GET `/student_sessions/{id}/id_card` can be allowed on its own. Since ProctorExam puts the exam and session id in the URL path, such as `/exams/{exam_id}/student_sessions` and `/student_sessions/{id}/assign_proctor`, a rule can also pin the agent to one specific exam or session.