> ## Documentation Index
> Fetch the complete documentation index at: https://docs.edpire.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Review Submission

> Everything needed to show a learner one of their past attempts exactly as
they saw it on submitting: the assessment content, their answers, and the
marking, with the expected answer on anything missed and the teacher's
comments on open responses.

Pass the response to the SDK's `EdpireAssessment.review()` unchanged. It
renders the paper read-only.

Call it from your server, after checking the attempt belongs to the
signed-in learner, and relay the result to the browser. Also pass
`learner_ref`: a submission belonging to anyone else then returns 404,
so a bug in your own ownership check cannot show one learner another's
paper.

Answer keys are never included. The reveal fields (`display_answer`,
`detail.correctChoiceIds`, `detail.correctPairings`) are the same ones
the submit response returned at the end of the attempt.

The paper is drawn from the assessment's current published content.
Answers and marks are keyed by question and node, so they survive a
republish.




## OpenAPI

````yaml GET /submissions/{id}/review
openapi: 3.1.0
info:
  title: Edpire API
  description: >
    Edpire is a headless assessment engine. This API lets you manage
    assessments,

    submit answers for grading, retrieve results, organise them into folders,
    and configure

    webhooks for real-time notifications.


    All responses use a consistent envelope: `{ data, error, meta }`.
  version: 1.0.0
  contact:
    name: Edpire Support
    url: https://edpire.com
  license:
    name: Proprietary
servers:
  - url: https://edpire.com/api/v1
    description: Production
security:
  - BearerAuth: []
tags:
  - name: Assessments
    description: Create, list, update, publish, and grade assessments
  - name: Submissions
    description: Retrieve submission details
  - name: Learners
    description: Query learner results
  - name: Webhooks
    description: Register and manage webhook endpoints
  - name: Embed
    description: Mint tokens and load assessments for browser-side rendering
  - name: Folders
    description: Nestable structure for filing assessments
  - name: Authoring
    description: Hand an author into the Edpire builder from your own admin
paths:
  /submissions/{id}/review:
    get:
      tags:
        - Submissions
      summary: Get a finished attempt as the corrected paper
      description: >
        Everything needed to show a learner one of their past attempts exactly
        as

        they saw it on submitting: the assessment content, their answers, and
        the

        marking, with the expected answer on anything missed and the teacher's

        comments on open responses.


        Pass the response to the SDK's `EdpireAssessment.review()` unchanged. It

        renders the paper read-only.


        Call it from your server, after checking the attempt belongs to the

        signed-in learner, and relay the result to the browser. Also pass

        `learner_ref`: a submission belonging to anyone else then returns 404,

        so a bug in your own ownership check cannot show one learner another's

        paper.


        Answer keys are never included. The reveal fields (`display_answer`,

        `detail.correctChoiceIds`, `detail.correctPairings`) are the same ones

        the submit response returned at the end of the attempt.


        The paper is drawn from the assessment's current published content.

        Answers and marks are keyed by question and node, so they survive a

        republish.
      operationId: getSubmissionReview
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
            format: uuid
        - name: learner_ref
          in: query
          description: The learner you expect to own this attempt. Strongly recommended.
          schema:
            type: string
      responses:
        '200':
          description: The attempt, ready for `EdpireAssessment.review()`
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/Envelope'
                  - type: object
                    properties:
                      data:
                        $ref: '#/components/schemas/SubmissionReview'
        '404':
          $ref: '#/components/responses/NotFound'
        '409':
          description: |
            The attempt cannot be drawn. One of: it has not been submitted yet;
            the assessment has been unpublished since; or it was recorded before
            per-question corrections were kept (SDK and REST attempts before
            September 2026). Its score is still available from
            `GET /submissions/{id}`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
      security:
        - BearerAuth:
            - read:results
components:
  schemas:
    Envelope:
      type: object
      properties:
        data: {}
        error:
          oneOf:
            - type: 'null'
            - $ref: '#/components/schemas/ErrorObject'
        meta:
          oneOf:
            - type: 'null'
            - type: object
    SubmissionReview:
      type: object
      properties:
        submission:
          type: object
          properties:
            id:
              type: string
              format: uuid
            assessment_id:
              type: string
              format: uuid
            learner_ref:
              type: string
              nullable: true
            status:
              type: string
            attempt_number:
              type: integer
            total_attempts:
              type: integer
              description: >-
                Attempts this learner has made at this assessment, this one
                included
            score:
              type: number
            max_score:
              type: number
            percentage:
              type: integer
            passed:
              type: boolean
            passing_score_percent:
              type: integer
            is_fully_graded:
              type: boolean
            awaiting_manual_grading:
              type: boolean
              description: >-
                True while a teacher still has open responses to mark. The
                player then hides the score.
            submitted_at:
              type: string
              format: date-time
        assessment:
          type: object
          description: >-
            Same shape as the embed content loader. Answer keys are always
            empty.
          properties:
            annex:
              type: object
              nullable: true
            exercises:
              type: array
              items:
                type: object
                properties:
                  id:
                    type: string
                  sharedContext:
                    type: object
                    nullable: true
                  questions:
                    type: array
                    items:
                      type: object
                      properties:
                        id:
                          type: string
                        version:
                          type: string
                        content:
                          type: object
                        answerKeys:
                          type: array
                          maxItems: 0
                          items: {}
        meta:
          type: object
          properties:
            id:
              type: string
              format: uuid
            title:
              type: string
            category:
              type: string
              nullable: true
            language:
              type: string
              enum:
                - en
                - fr
            settings:
              type: object
        branding:
          type: object
          nullable: true
        answers:
          type: object
          description: The learner's answers, in the shape the player collected them
          properties:
            exerciseAnswers:
              type: array
              items:
                type: object
                properties:
                  exerciseId:
                    type: string
                  questionAnswers:
                    type: array
                    items:
                      type: object
                      properties:
                        questionId:
                          type: string
                        answers:
                          type: array
                          items:
                            type: object
        exercise_feedback:
          type: array
          description: >-
            Per-node marking. Same shape as the embed submit response, plus
            `teacher_feedback`.
          items:
            type: object
            properties:
              exercise_id:
                type: string
              questions:
                type: array
                items:
                  type: object
                  properties:
                    question_id:
                      type: string
                    node_results:
                      type: array
                      items:
                        type: object
                        properties:
                          node_id:
                            type: string
                          status:
                            type: string
                            enum:
                              - correct
                              - partial
                              - incorrect
                              - awaiting_review
                          score:
                            type: number
                          max_score:
                            type: number
                          feedback:
                            type: string
                            description: >-
                              The grader's written comment, e.g. on an AI-graded
                              answer
                          display_answer:
                            type: string
                          detail:
                            type: object
                          teacher_feedback:
                            type: array
                            description: >-
                              The teacher's written comment on an open response,
                              as rich content
                            items:
                              type: object
    ErrorResponse:
      type: object
      properties:
        data:
          type: 'null'
        error:
          $ref: '#/components/schemas/ErrorObject'
        meta:
          type: 'null'
    ErrorObject:
      type: object
      required:
        - message
      properties:
        message:
          type: string
  responses:
    NotFound:
      description: Resource not found
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      description: >
        API key starting with `edp_live_`. Pass via `Authorization: Bearer
        edp_live_xxx`.


        Scopes: `read:assessments`, `write:assessments`, `read:results`,
        `write:submissions`.

````