{id}`#

Retrieve execution result for a submission.

Request#

curl -s "https://api.rustbox.orkait.com/api/result/550e8400-e29b-41d4-a716-446655440000" \
  -H "X-API-Key: rb_live_your_key_here" | jq

Response#

{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "language": "python",
  "job_status": "completed",
  "schema_version": "1.0",
  "verdict": "AC",
  "exit_code": 0,
  "signal": null,
  "stdout": "hello world\n",
  "stderr": "",
  "output_integrity": "complete",
  "error_message": null,
  "cpu_time_secs": 0.015,
  "wall_time_secs": 0.052,
  "memory_peak_bytes": 8400000,
  "evidence": {
    "verdict_cause": "normal_exit",
    "verdict_actor": "runtime",
    "isolation_mode": "strict",
    "controls_applied": ["pid_namespace", "mount_namespace", "network_namespace", "memory_limit", "process_limit", "no_new_privileges"],
    "controls_missing": [],
    "cgroup": {
      "memory_limit_bytes": 268435456,
      "memory_peak_bytes": 8400000,
      "oom_events": 0,
      "oom_kill_events": 0,
      "cpu_usage_usec": 15000,
      "process_count": 0,
      "process_limit": 10
    },
    "timing": {
      "cpu_ms": 15,
      "wall_ms": 52,
      "cpu_wall_ratio": 0.29,
      "divergence": "cpu_bound"
    },
    "process_lifecycle": {
      "reap_status": "clean",
      "descendant_containment": "ok",
      "zombie_count": 0
    },
    "judge_actions": [],
    "collection_errors": []
  },
  "created_at": "2026-04-02T12:00:00.000Z",
  "started_at": "2026-04-02T12:00:00.001Z",
  "completed_at": "2026-04-02T12:00:00.053Z"
}

Response fields#

Top-level fields#

Field	Type	Present	Description
`id`	string (UUID)	always	Submission identifier
`language`	string	always	Language used for execution
`job_status`	string	always	`pending`, `running`, `completed`, or `error`
`schema_version`	string	always	API schema version (currently `"1.0"`)
`verdict`	string or null	when completed	Verdict code: `AC`, `RE`, `TLE`, `MLE`, `PLE`, `FSE`, `SIG`, `IE`
`exit_code`	integer or null	when completed	Process exit code
`signal`	integer or null	when completed	Signal number that killed the process, or `null`
`stdout`	string or null	when completed	Captured standard output
`stderr`	string or null	when completed	Captured standard error
`output_integrity`	string or null	when completed	`complete`, `truncated_by_judge_limit`, `crash_mid_write`, or `write_error`
`error_message`	string or null	when completed	Human-readable error description, or `null` on success
`cpu_time_secs`	number or null	when completed	CPU time consumed in seconds
`wall_time_secs`	number or null	when completed	Wall clock time in seconds
`memory_peak_bytes`	integer or null	when completed	Peak resident memory in bytes
`evidence`	object or null	when completed	Kernel-backed execution evidence (see below)
`created_at`	string	always	ISO 8601 timestamp when the submission was created
`started_at`	string or null	when started	ISO 8601 timestamp when execution began
`completed_at`	string or null	when completed	ISO 8601 timestamp when execution finished

`output_integrity` values#

Value	Meaning
`complete`	All output was captured without loss
`truncated_by_judge_limit`	Output exceeded the capture limit and was truncated
`crash_mid_write`	Process crashed while writing output
`write_error`	An I/O error occurred during output capture

`evidence` object#

Field	Type	Description
`verdict_cause`	string	Why the verdict was assigned (e.g. `normal_exit`, `oom_kill`, `wall_timeout`)
`verdict_actor`	string	What assigned the verdict (`runtime`, `kernel`, `supervisor`)
`isolation_mode`	string	Isolation level applied (`strict`)
`controls_applied`	string[]	Security controls active during execution
`controls_missing`	string[]	Controls that could not be applied (normally empty)
`cgroup`	object	Cgroup accounting data (see below)
`timing`	object	Timing breakdown (see below)
`process_lifecycle`	object	Process reaping and containment status
`judge_actions`	array	Actions taken by the supervisor (e.g. SIGKILL on timeout)
`collection_errors`	string[]	Errors encountered while collecting evidence

`evidence.cgroup` object#

Field	Type	Description
`memory_limit_bytes`	integer	Memory limit applied to the cgroup
`memory_peak_bytes`	integer	Peak memory usage recorded by the cgroup
`oom_events`	integer	Number of OOM events
`oom_kill_events`	integer	Number of OOM kill events
`cpu_usage_usec`	integer	CPU time in microseconds
`process_count`	integer	Number of processes at collection time
`process_limit`	integer	PID limit applied to the cgroup

`evidence.timing` object#

Field	Type	Description
`cpu_ms`	integer	CPU time in milliseconds
`wall_ms`	integer	Wall clock time in milliseconds
`cpu_wall_ratio`	number	Ratio of CPU to wall time
`divergence`	string	Timing classification (e.g. `cpu_bound`, `io_bound`)

`evidence.process_lifecycle` object#

Field	Type	Description
`reap_status`	string	Whether all processes were cleanly reaped (`clean`)
`descendant_containment`	string	Whether all child processes were contained (`ok`)
`zombie_count`	integer	Number of zombie processes at collection time

Status lifecycle#

pending -> running -> completed
                   -> error

Status	Meaning
`pending`	Queued, waiting for a worker
`running`	Executing in a sandbox
`completed`	Finished (check `verdict` for the outcome)
`error`	Internal failure

Verdicts#

Code	Name	What happened
`AC`	Accepted	Clean exit, code 0
`RE`	Runtime Error	Non-zero exit or crash
`TLE`	Time Limit Exceeded	Wall time exceeded
`MLE`	Memory Limit Exceeded	OOM killed by cgroup
`PLE`	Process Limit Exceeded	Fork/thread bomb hit cgroup PID limit
`FSE`	File Size Exceeded	SIGXFSZ from RLIMIT_FSIZE
`SIG`	Signaled	Killed by signal (not attributed to platform)
`IE`	Internal Error	Platform infrastructure failed

Every verdict is backed by kernel evidence. MLE means the cgroup OOM killer fired. TLE means the wall timer expired. PLE means the cgroup PID limit was reached. FSE means a write exceeded the file size rlimit. The platform does not guess verdicts from exit codes.

What happens on timeout#

When a submission exceeds its wall time limit, the supervisor sends SIGKILL to the process. The resulting verdict is TLE.

Because the process is forcibly killed, stdout may be incomplete. Check the output_integrity field - it will indicate crash_mid_write or truncated_by_judge_limit if output was not fully captured.

The evidence.judge_actions array will contain the kill event, and evidence.verdict_cause will be wall_timeout. Example:

{
  "verdict": "TLE",
  "wall_time_secs": 7.001,
  "output_integrity": "crash_mid_write",
  "evidence": {
    "verdict_cause": "wall_timeout",
    "verdict_actor": "supervisor",
    "judge_actions": ["sigkill_on_wall_timeout"]
  }
}

Not found#

HTTP 404

{ "error": "submission not found" }

GET /api/result/{id}#