CoderPad · Schema

detailed_result

CompanyArtificial IntelligenceHiringTechnical AssessmentInterviewPlatform

Properties

Name Type Description
status string the test status
url string url to the test report through the dashboard application
report object
id integer the test id
id_test integer the test id (deprecated, see id)
organization_id string the organization id
campaign_id integer the campaign id
candidate_name string the name of the candidate
candidate_email string the email of the candidate
tags array the tags of the candidate
send_time integer timestamp (in milliseconds) when the test has been sent
start_time integer timestamp (in milliseconds) when the test has been started
end_time integer timestamp (in milliseconds) when the test has been ended
test_url string the url to the test
candidate_language string the language chosen by the candidate to take the test if they started the test, null otherwise
last_activity_time integer time (in milliseconds) of the candidate's last activity (last submit or code test)
approval_status string approval status of the candidate (PASSED, REJECTED, TO_REVIEW)
timer_type string how the test times the candidate. PER_QUESTION is the only mode where a question has a limit of its own, so it is the only one where a question carries a time_limit_seconds: a GLOBAL test times the wh
questions array the questions of the test with their detailed report data. Omitted when the caller is not allowed to access detailed reports
View JSON Schema on GitHub

JSON Schema

coderpad-detailed-result-schema.json Raw ↑
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://artifacts.apis.io/coderpad/json-schema/coderpad-detailed-result-schema.json",
  "title": "detailed_result",
  "x-generated": "2026-11-04",
  "x-method": "derived",
  "x-generator": "derive-json-schema.py",
  "x-source": "openapi/coderpad-tests-api-openapi.yml#/components/schemas/detailed_result",
  "type": "object",
  "properties": {
    "status": {
      "type": "string",
      "description": "the test status",
      "enum": [
        "aborted",
        "canceled",
        "completed",
        "expired",
        "in progress",
        "waiting",
        "need review"
      ]
    },
    "url": {
      "type": "string",
      "description": "url to the test report through the dashboard application"
    },
    "report": {
      "$ref": "#/$defs/report"
    },
    "id": {
      "type": "integer",
      "description": "the test id",
      "format": "int32"
    },
    "id_test": {
      "type": "integer",
      "description": "the test id (deprecated, see id)",
      "format": "int32"
    },
    "organization_id": {
      "type": "string",
      "description": "the organization id"
    },
    "campaign_id": {
      "type": "integer",
      "description": "the campaign id",
      "format": "int32"
    },
    "candidate_name": {
      "type": "string",
      "description": "the name of the candidate"
    },
    "candidate_email": {
      "type": "string",
      "description": "the email of the candidate"
    },
    "tags": {
      "type": "array",
      "description": "the tags of the candidate",
      "items": {
        "type": "string",
        "description": "the tags of the candidate"
      }
    },
    "send_time": {
      "type": "integer",
      "description": "timestamp (in milliseconds) when the test has been sent",
      "format": "int64"
    },
    "start_time": {
      "type": "integer",
      "description": "timestamp (in milliseconds) when the test has been started",
      "format": "int64"
    },
    "end_time": {
      "type": "integer",
      "description": "timestamp (in milliseconds) when the test has been ended",
      "format": "int64"
    },
    "test_url": {
      "type": "string",
      "description": "the url to the test"
    },
    "candidate_language": {
      "type": "string",
      "description": "the language chosen by the candidate to take the test if they started the test, null otherwise"
    },
    "last_activity_time": {
      "type": "integer",
      "description": "time (in milliseconds) of the candidate's last activity (last submit or code test)",
      "format": "int64"
    },
    "approval_status": {
      "type": "string",
      "description": "approval status of the candidate (PASSED, REJECTED, TO_REVIEW)"
    },
    "timer_type": {
      "type": "string",
      "description": "how the test times the candidate. PER_QUESTION is the only mode where a question has a limit of its own, so it is the only one where a question carries a time_limit_seconds: a GLOBAL test times the whole session and an UNLIMITED one times nothing. Omitted on a test the candidate never started",
      "enum": [
        "PER_QUESTION",
        "GLOBAL",
        "UNLIMITED"
      ]
    },
    "questions": {
      "type": "array",
      "description": "the questions of the test with their detailed report data. Omitted when the caller is not allowed to access detailed reports",
      "items": {
        "$ref": "#/$defs/test_question"
      }
    }
  },
  "$defs": {
    "accepted_answer": {
      "type": "object",
      "properties": {
        "value": {
          "type": "string",
          "description": "the accepted answer, as an exact value or a regular expression"
        },
        "match_type": {
          "type": "string",
          "description": "how the candidate answer is compared with this accepted answer: EXACT is a case insensitive, trimmed equality, REGEX a full match of the whole answer. Same values as the question API publishes",
          "enum": [
            "EXACT",
            "REGEX"
          ]
        }
      },
      "description": "an answer the question accepts as correct, the candidate answer is matched against each of them"
    },
    "ai_review": {
      "type": "object",
      "properties": {
        "rationale": {
          "type": "string",
          "description": "the message explaining the AI recommendation"
        },
        "recommended_outcome": {
          "type": "string",
          "description": "the verdict the AI recommends on this criterion, stated the same way as outcome so a caller never has to translate one into the other. Only ever PASSED or FAILED: the AI reaching no recommendation is reported by omitting this field, see no_recommendation_reason",
          "enum": [
            "PASSED",
            "FAILED"
          ]
        },
        "no_recommendation_reason": {
          "type": "string",
          "description": "why the AI produced no recommendation for this criterion. Omitted when it did. This never describes the candidate's result, only the AI review",
          "enum": [
            "CONFIDENCE_SCORE_TOO_LOW",
            "EMPTY_SUBMISSION",
            "TRANSCRIPT_NOT_AVAILABLE",
            "AI_REVIEW_FAILED"
          ]
        }
      },
      "description": "AI assisted review of a rubric criterion"
    },
    "answer": {
      "type": "object",
      "properties": {
        "code_answer": {
          "$ref": "#/$defs/code_answer"
        },
        "game_answer": {
          "$ref": "#/$defs/game_answer"
        },
        "mcq_answer": {
          "$ref": "#/$defs/mcq_answer"
        },
        "text_answer": {
          "$ref": "#/$defs/text_answer"
        },
        "file_upload_answer": {
          "$ref": "#/$defs/file_upload_answer"
        },
        "project_answer": {
          "$ref": "#/$defs/project_answer"
        },
        "video_answer": {
          "$ref": "#/$defs/video_answer"
        }
      },
      "description": "the answer of the candidate, in the {type}_answer sub-block of the question type"
    },
    "choice": {
      "type": "object",
      "properties": {
        "label": {
          "type": "string",
          "description": "the choice label, in the language the candidate took the test in"
        }
      },
      "description": "a single choice of an MCQ question"
    },
    "choice_selection": {
      "type": "object",
      "properties": {
        "correct_choice_indexes": {
          "type": "array",
          "description": "zero based positions of the correct choices in mcq_details.choices, to compare with answer.mcq_answer.selected_choice_indexes. Same positions as the correct_choice_indexes of GET /v1.1/questions/{id}",
          "items": {
            "type": "integer",
            "description": "zero based positions of the correct choices in mcq_details.choices, to compare with answer.mcq_answer.selected_choice_indexes. Same positions as the correct_choice_indexes of GET /v1.1/questions/{id}",
            "format": "int32"
          }
        }
      },
      "description": "the choices the candidate had to select"
    },
    "code_answer": {
      "type": "object",
      "properties": {
        "code": {
          "type": "string",
          "description": "the code of the candidate's last submission"
        },
        "programming_language_id": {
          "type": "string",
          "description": "id of the programming language chosen by the candidate. Omitted on a question available in a single language, since the question imposes it"
        }
      },
      "description": "what the candidate submitted on a CODE question"
    },
    "evaluation": {
      "type": "object",
      "properties": {
        "rubric": {
          "$ref": "#/$defs/rubric"
        },
        "test_report": {
          "$ref": "#/$defs/test_report"
        },
        "validation_code": {
          "$ref": "#/$defs/validation_code"
        },
        "input_output": {
          "$ref": "#/$defs/input_output"
        },
        "sql_query_result_comparison": {
          "$ref": "#/$defs/sql_query_result_comparison"
        },
        "text_answer_matching": {
          "$ref": "#/$defs/text_answer_matching"
        },
        "choice_selection": {
          "$ref": "#/$defs/choice_selection"
        }
      },
      "description": "how the candidate answer was graded, and the result of each grading criterion"
    },
    "file_upload_answer": {
      "type": "object",
      "properties": {
        "filename": {
          "type": "string",
          "description": "name of the file uploaded by the candidate"
        },
        "download_url": {
          "type": "string",
          "description": "signed download url of the file uploaded by the candidate. This url is temporary and expires, do not store it"
        },
        "candidate_comment": {
          "type": "string",
          "description": "comment left by the candidate along with the file"
        }
      },
      "description": "what the candidate uploaded on a FILE_UPLOAD question"
    },
    "game_answer": {
      "type": "object",
      "properties": {
        "code": {
          "type": "string",
          "description": "the code of the candidate's last submission"
        },
        "programming_language_id": {
          "type": "string",
          "description": "id of the programming language chosen by the candidate. Omitted on a question available in a single language, since the question imposes it"
        }
      },
      "description": "what the candidate submitted on a GAME question"
    },
    "input_output": {
      "type": "object",
      "properties": {
        "test_cases": {
          "type": "array",
          "description": "test cases of the question, each with its result. A question nesting its validators returns the whole tree flattened, a parent before its own children, so the max_points of the list add up to the question max_points",
          "items": {
            "$ref": "#/$defs/input_output_test_case"
          }
        }
      },
      "description": "result of the test cases comparing the output of the candidate code with the expected one"
    },
    "input_output_test_case": {
      "type": "object",
      "properties": {
        "label": {
          "type": "string",
          "description": "the test case label"
        },
        "skill": {
          "type": "string",
          "description": "skill assessed by this test case"
        },
        "outcome": {
          "type": "string",
          "description": "verdict of the test case. NOT_RUN when it was never run, typically because the candidate never submitted or a previous test case timed out: an unrun test case is undecided, never failed. PENDING_MANUAL_REVIEW never applies here, only a rubric criterion waits for a human",
          "enum": [
            "PASSED",
            "FAILED",
            "NOT_RUN",
            "PENDING_MANUAL_REVIEW"
          ]
        },
        "max_points": {
          "type": "integer",
          "description": "points the test case is worth, the points of the question API",
          "format": "int32"
        },
        "awarded_points": {
          "type": "integer",
          "description": "points the candidate obtained on this test case, null while it has not been decided",
          "format": "int32"
        },
        "result_message": {
          "type": "string",
          "description": "explains the result of this test case: the test runner output, or the reason it was not run. Free text meant to be displayed, not parsed"
        },
        "result_overridden_by_recruiter": {
          "type": "boolean",
          "description": "whether a recruiter set this result by hand instead of leaving it to the automatic grading. A CoderPad admin or a write-access shared report can do it too, never CoderPad itself. outcome and awarded_points already reflect it, so a caller never applies it itself"
        },
        "timed_out": {
          "type": "boolean",
          "description": "whether the test case timed out"
        }
      },
      "description": "result of one test case comparing the output of the candidate code with the expected one"
    },
    "mcq_answer": {
      "type": "object",
      "properties": {
        "selected_choice_indexes": {
          "type": "array",
          "description": "zero based positions of the choices the candidate picked, in mcq_details.choices",
          "items": {
            "type": "integer",
            "description": "zero based positions of the choices the candidate picked, in mcq_details.choices",
            "format": "int32"
          }
        }
      },
      "description": "what the candidate picked on an MCQ question"
    },
    "mcq_details": {
      "type": "object",
      "properties": {
        "choices": {
          "type": "array",
          "description": "every choice of the question, listed in the question's own order. A choice is pointed at by its position in this list, the way GET /v1.1/questions/{id} does, by correct_choice_indexes and by answer.mcq_answer.selected_choice_indexes",
          "items": {
            "$ref": "#/$defs/choice"
          }
        },
        "selection_mode": {
          "type": "string",
          "description": "whether the candidate can select one or multiple choices: SINGLE or MULTIPLE",
          "enum": [
            "SINGLE",
            "MULTIPLE"
          ]
        },
        "randomize_choices": {
          "type": "boolean",
          "description": "whether MCQ choices are randomized"
        }
      },
      "description": "MCQ specific configuration of the question"
    },
    "project_answer": {
      "type": "object",
      "properties": {
        "download_url": {
          "type": "string",
          "description": "url of the endpoint building the candidate project archive (question project with the candidate changes applied). It requires the API-Key header and generates the archive on demand, so expect a slow response. Only returned when the candidate submitted the project at least once."
        },
        "ai_assist_conversation_count": {
          "type": "integer",
          "description": "number of conversations the candidate had with the AI assistant on this question. Fetch them from GET /tests/{id}/questions/{questionId}/ai-assist-conversations.",
          "format": "int32"
        }
      },
      "description": "what the candidate submitted on a PROJECT question"
    },
    "recording": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "description": "the recording id",
          "format": "uuid"
        },
        "url": {
          "type": "string",
          "description": "signed url of the recording. This url is temporary and expires, do not store it. Only returned when video_details.recording_availability is AVAILABLE"
        },
        "transcript_url": {
          "type": "string",
          "description": "signed url of the recording transcript. This url is temporary and expires. Returned whenever the transcript file still exists, even when the recording itself is gone: anonymisation deletes the media and keeps the transcript, while the candidate's own deletion removes both"
        },
        "duration_seconds": {
          "type": "integer",
          "description": "length (in seconds) of the recording, not a time the candidate spent",
          "format": "int32"
        }
      },
      "description": "a single recording of a VIDEO answer"
    },
    "report": {
      "type": "object",
      "properties": {
        "duration": {
          "type": "integer",
          "description": "duration (in seconds) spent by the candidate to complete the test",
          "format": "int64"
        },
        "warnings": {
          "type": "array",
          "description": "warnings about the test",
          "items": {
            "type": "string",
            "description": "warnings about the test"
          }
        },
        "points": {
          "type": "integer",
          "description": "number of points awarded to the test",
          "format": "int32"
        },
        "score": {
          "type": "number",
          "description": "number of points in percentage",
          "format": "double"
        },
        "technologies": {
          "type": "object",
          "additionalProperties": {
            "$ref": "#/$defs/report_technology"
          }
        },
        "total_duration": {
          "type": "integer",
          "description": "maximal duration (in seconds) available for the test",
          "format": "int64"
        },
        "total_points": {
          "type": "integer",
          "description": "available points for the test",
          "format": "int32"
        },
        "comparative_score": {
          "type": "number",
          "description": "candidate score compared with developers who have taken a similar test",
          "format": "double"
        },
        "community_stats": {
          "type": "array",
          "items": {
            "type": "integer",
            "format": "int32"
          }
        },
        "marked_as_cheated_by_recruiter": {
          "type": "boolean",
          "description": "whether a recruiter manually flagged this candidate as cheated. Never set by CoderPad: the platform own detections are reported as warnings instead. The question level flag is questions[].marked_as_cheated_by_recruiter"
        },
        "time_spent_outside_environment_seconds": {
          "type": "integer",
          "description": "total time (in seconds) the candidate spent with the environment out of focus during the test",
          "format": "int64"
        },
        "environment_exit_count": {
          "type": "integer",
          "description": "number of times the candidate left the environment during the test",
          "format": "int32"
        }
      },
      "description": "the test report"
    },
    "report_skill": {
      "type": "object",
      "properties": {
        "points": {
          "type": "integer",
          "description": "number of points awarded to the test for the given technology and the specific skill",
          "format": "int32"
        },
        "score": {
          "type": "number",
          "description": "number of points in percentage for the given technology and the specific skill",
          "format": "double"
        },
        "total_points": {
          "type": "integer",
          "description": "available points for the test for the given technology and the specific skill",
          "format": "int32"
        }
      },
      "description": "report by skill for a given technology - the property name is the skill name, 'Language Knowledge' or 'Problem Solving' for instance"
    },
    "report_technology": {
      "type": "object",
      "properties": {
        "points": {
          "type": "integer",
          "description": "number of points awarded to the test for the given technology",
          "format": "int32"
        },
        "score": {
          "type": "number",
          "description": "number of points in percentage for the given technology",
          "format": "double"
        },
        "skills": {
          "type": "object",
          "additionalProperties": {
            "$ref": "#/$defs/report_skill"
          }
        },
        "total_points": {
          "type": "integer",
          "description": "available points for the test for the given technology",
          "format": "int32"
        },
        "comparative_score": {
          "type": "number",
          "description": "candidate score compared with developers who have taken a similar test for the given technology",
          "format": "double"
        }
      },
      "description": "report by technology - the property name is the technology name, 'PHP' for instance"
    },
    "rubric": {
      "type": "object",
      "properties": {
        "criteria": {
          "type": "array",
          "description": "criteria of the rubric, in the order the question defines them, each with the result of its review",
          "items": {
            "$ref": "#/$defs/rubric_criterion"
          }
        }
      },
      "description": "result of the review of the answer against the question rubric"
    },
    "rubric_criterion": {
      "type": "object",
      "properties": {
        "label": {
          "type": "string",
          "description": "the criterion label"
        },
        "description": {
          "type": "string",
          "description": "reviewer-facing description of what the criterion expects"
        },
        "skill": {
          "type": "string",
          "description": "skill assessed by this criterion"
        },
        "outcome": {
          "type": "string",
          "description": "verdict of the criterion. PENDING_MANUAL_REVIEW while a human still has to grade it, which puts the whole question in PENDING_MANUAL_REVIEW too. NOT_RUN when nobody is expected to grade it, typically because the candidate never answered the question. An AI_GRADING criterion is graded by the AI, so it is decided without ever being PENDING_MANUAL_REVIEW",
          "enum": [
            "PASSED",
            "FAILED",
            "NOT_RUN",
            "PENDING_MANUAL_REVIEW"
          ]
        },
        "max_points": {
          "type": "integer",
          "description": "points the criterion is worth, the points of the question API",
          "format": "int32"
        },
        "awarded_points": {
          "type": "integer",
          "description": "points the reviewer awarded, null while the criterion has not been reviewed",
          "format": "int32"
        },
        "result_message": {
          "type": "string",
          "description": "explains the result of this criterion. Free text meant to be displayed, not parsed. Only on a question whose criteria are validators the platform records a message for, such as a FILE_UPLOAD"
        },
        "result_overridden_by_recruiter": {
          "type": "boolean",
          "description": "whether a recruiter set this result by hand instead of leaving it to the grading. A CoderPad admin or a write-access shared report can do it too, never CoderPad itself. outcome and awarded_points already reflect it, so a caller never applies it itself"
        },
        "review_mode": {
          "type": "string",
          "description": "how the criterion is reviewed, the review_mode of the question API",
          "enum": [
            "HUMAN_ONLY",
            "AI_SUGGESTIONS",
            "AI_GRADING"
          ]
        },
        "ai_review": {
          "$ref": "#/$defs/ai_review"
        }
      },
      "description": "result of one criterion of the rubric the answer was reviewed against"
    },
    "sql_query_result_comparison": {
      "type": "object",
      "properties": {
        "outcome": {
          "type": "string",
          "description": "verdict of the comparison. NOT_RUN when it was never run, typically because the candidate never submitted: an unrun comparison is undecided, never failed",
          "enum": [
            "PASSED",
            "FAILED",
            "NOT_RUN",
            "PENDING_MANUAL_REVIEW"
          ]
        },
        "max_points": {
          "type": "integer",
          "description": "points the comparison is worth, which is the whole question",
          "format": "int32"
        },
        "awarded_points": {
          "type": "integer",
          "description": "points the candidate obtained, null while the comparison has not been decided",
          "format": "int32"
        },
        "result_message": {
          "type": "string",
          "description": "explains the result of the comparison. Free text meant to be displayed, not parsed"
        },
        "result_overridden_by_recruiter": {
          "type": "boolean",
          "description": "whether a recruiter set this result by hand instead of leaving it to the automatic grading. A CoderPad admin or a write-access shared report can do it too, never CoderPad itself. outcome and awarded_points already reflect it, so a caller never applies it itself"
        },
        "timed_out": {
          "type": "boolean",
          "description": "whether the query timed out"
        }
      },
      "description": "result of comparing the candidate query result with the reference one"
    },
    "test_question": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "description": "the question global id, stable across versions. Same id as GET /v1.1/questions/{id}",
          "format": "uuid"
        },
        "version": {
          "type": "integer",
          "description": "the version of the question the candidate answered",
          "format": "int32"
        },
        "type": {
          "type": "string",
          "description": "the question type, with the same values as the question API publishes",
          "enum": [
            "CODE",
            "MCQ",
            "TEXT",
            "GAME",
            "FILE_UPLOAD",
            "PROJECT",
            "VIDEO",
            "MULTI"
          ]
        },
        "title": {
          "type": "string",
          "description": "the question title"
        },
        "domain": {
          "type": "string",
          "description": "the question domain name"
        },
        "warnings": {
          "type": "array",
          "description": "warnings raised on this question. report.warnings holds the test session ones, so a warning is here or there, never in both",
          "items": {
            "$ref": "#/$defs/warning"
          }
        },
        "evaluation": {
          "$ref": "#/$defs/evaluation"
        },
        "answer": {
          "$ref": "#/$defs/answer"
        },
        "max_points": {
          "type": "integer",
          "description": "points the question is worth",
          "format": "int32"
        },
        "awarded_points": {
          "type": "integer",
          "description": "points the candidate obtained on this question. A question waiting for its review reports the points already awarded, 0 when none is. Omitted while the test is not finished, and on a campaign hiding the scores from the recruiters, where max_points is omitted too",
          "format": "int32"
        },
        "time_limit_seconds": {
          "type": "integer",
          "description": "time limit (in seconds) of the question. Only returned when the test timer_type is PER_QUESTION, the only mode where a question has a limit of its own",
          "format": "int32"
        },
        "time_spent_seconds": {
          "type": "integer",
          "description": "time (in seconds) the candidate actually spent on this question, whatever the timer_type. Can exceed time_limit_seconds when the timer was tampered with",
          "format": "int64"
        },
        "first_access_time": {
          "type": "integer",
          "description": "timestamp (in milliseconds) of the first time the candidate opened the question",
          "format": "int64"
        },
        "submission_time": {
          "type": "integer",
          "description": "timestamp (in milliseconds) at which the candidate submitted this question, the last submission when there are several. Absent when the candidate never submitted it. A save or a code test does not move it, last_activity_time does",
          "format": "int64"
        },
        "last_activity_time": {
          "type": "integer",
          "description": "timestamp (in milliseconds) of the candidate's last activity on this question (last submit or code test)",
          "format": "int64"
        },
        "answer_status": {
          "type": "string",
          "description": "what the candidate produced on this question, whatever its type. Resolved in that order: NOT_STARTED (no first_access_time), NOT_SUBMITTED (no submission_time), EMPTY (submitted nothing at all), STARTER_CODE_UNCHANGED (submitted the starter untouched, CODE, GAME and PROJECT only), ANSWERED otherwise. Returned while the test is still running as well, unlike the other candidate fields: it says where the candidate stands, not how they did, and it can still change until the test ends",
          "enum": [
            "NOT_STARTED",
            "NOT_SUBMITTED",
            "EMPTY",
            "STARTER_CODE_UNCHANGED",
            "ANSWERED"
          ]
        },
        "grading_status": {
          "type": "string",
          "description": "how far the grading of the question went, so a caller knows whether awarded_points can still change. GRADED when every criterion that could be decided was, PENDING_MANUAL_REVIEW while a human still has to grade one of them, NOT_GRADED when none was ever decided, typically an unanswered question. It is not a verdict: awarded_points against max_points and the outcome of each criterion carry the result itself",
          "enum": [
            "GRADED",
            "PENDING_MANUAL_REVIEW",
            "NOT_GRADED"
          ]
        },
        "timed_out": {
          "type": "boolean",
          "description": "whether the candidate ran out of time on this question"
        },
        "result_overridden_by_recruiter": {
          "type": "boolean",
          "description": "whether a recruiter set the result of this question by hand instead of leaving it to the automatic grading. A CoderPad admin or a write-access shared report can do it too, never CoderPad itself. awarded_points already reflects it, so a caller never applies it itself. Each test case carries the same flag for its own result"
        },
        "marked_as_cheated_by_recruiter": {
          "type": "boolean",
          "description": "whether a recruiter manually flagged this answer as cheated. Never set by CoderPad: the platform own detections are reported as warnings instead. The candidate level flag is report.marked_as_cheated_by_recruiter"
        },
        "time_spent_outside_environment_seconds": {
          "type": "integer",
          "description": "total time (in seconds) the candidate spent with the environment out of focus during this question",
          "format": "int64"
        },
        "environment_exit_count": {
          "type": "integer",
          "description": "number of times the candidate left the environment during this question",
          "format": "int32"
        },
        "mcq_details": {
          "$ref": "#/$defs/mcq_details"
        }
      },
      "description": "detailed report data of a single question of the test"
    },
    "test_report": {
      "type": "object",
      "properties": {
        "test_cases": {
          "type": "array",
          "description": "tests of the suite, in the order the question defines them, each with its result",
          "items": {
            "$ref": "#/$defs/test_report_test_case"
          }
        }
      },
      "description": "result of the project test suite run on the candidate answer"
    },
    "test_report_test_case": {
      "type": "object",
      "properties": {
        "key": {
          "type": "string",
          "description": "stable identifier of the test case, the key of the question API"
        },
        "label": {
          "type": "string",
          "description": "the test case label"
        },
        "skill": {
          "type": "string",
          "description": "skill assessed by this test case"
        },
        "outcome": {
          "type": "string",
          "description": "verdict of the test case. NOT_RUN when the suite never ran it, typically because the candidate never submitted: an unrun test case is undecided, never failed. PENDING_MANUAL_REVIEW never applies here, only a rubric criterion waits for a human",
          "enum": [
            "PASSED",
            "FAILED",
            "NOT_RUN",
            "PENDING_MANUAL_REVIEW"
          ]
        },
        "output": {
          "type": "string",
          "description": "raw output produced by the test run"
        },
        "test_identifier": {
          "type": "string",
          "description": "identifier of the test in the project test suite"
        },
        "max_points": {
          "type": "integer",
          "description": "points the test case is worth, the points of the question API",
          "format": "int32"
        },
        "awarded_points": {
          "type": "integer",
          "description": "points the candidate obtained on this test case, null while it has not been decided",
          "format": "int32"
        },
        "result_overridden_by_recruiter": {
 

# --- truncated at 32 KB (38 KB total) ---
# Full source: https://artifacts.apis.io/coderpad/json-schema/coderpad-detailed-result-schema.json

Work with this as data

Every JSON Schema here is available over the APIs.io API and to AI agents over MCP.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for schemas

4 MCP tools reach this
  • find_json_schemasBrowse and filter every JSON Schema in the catalog.
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
This JSON Schema
curl "https://apis.io/api/v1/json-schemas/coderpad-detailed-result"
All schemas
curl "https://apis.io/api/v1/json-schemas?limit=25"

Calls without X-API-Key need no key. Calls with it need a paid plan — get a key.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. See our Privacy Policy and Terms.

A second provider on the same verified email joins the account you already have.