unsandbox.com

Execute code immediately and wait for results. Best for quick scripts and interactive use.

Request Parameters

Example (Kotlin)

import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject

val client = OkHttpClient()
val mediaType = "application/json".toMediaType()

val json = JSONObject().apply {
    put("language", "kotlin")
    put("code", "println(\"Hello from unsandbox!\")")
}

val request = Request.Builder()
    .url("https://api.unsandbox.com/execute")
    .addHeader("Content-Type", "application/json")
    .addHeader("Authorization", "Bearer System.getenv("UNSANDBOX_API_KEY") ?: "unsb-sk-test0-vault-unlck-12345"")
    .post(json.toString().toRequestBody(mediaType))
    .build()

client.newCall(request).execute().use { response ->
    val result = JSONObject(response.body!!.string())
    if (result.getBoolean("success")) {
        println("Output: ${result.getString("stdout")}")
    } else {
        println("Error: ${result.getString("error")}")
    }
}

Response (Success)

{
  "success": true,
  "stdout": "Hello from unsandbox!\n",
  "stderr": "",
  "error": null,
  "language": "python",
  "exit_code": 0
}

Response (Error)

{
  "success": false,
  "error": "Syntax error in code",
  "stderr": "SyntaxError: invalid syntax\n"
}

Submit code for execution and receive a job ID to poll for results. Best for long-running scripts or when you need to decouple submission from execution.

Request Parameters

Example (Kotlin)

import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject

val client = OkHttpClient()
val mediaType = "application/json".toMediaType()

// Submit job
val json = JSONObject().apply {
    put("language", "rust")
    put("code", "fn main() { println!(\"Computing...\"); }")
    put("ttl", 300)
}

val request = Request.Builder()
    .url("https://api.unsandbox.com/execute/async")
    .addHeader("Content-Type", "application/json")
    .addHeader("Authorization", "Bearer System.getenv("UNSANDBOX_API_KEY") ?: "unsb-sk-test0-vault-unlck-12345"")
    .post(json.toString().toRequestBody(mediaType))
    .build()

val jobId = client.newCall(request).execute().use { response ->
    JSONObject(response.body!!.string()).getString("job_id")
}

println("Job submitted: $jobId")

// Poll for results
while (true) {
    val statusRequest = Request.Builder()
        .url("https://api.unsandbox.com/jobs/$jobId")
        .addHeader("Authorization", "Bearer System.getenv("UNSANDBOX_API_KEY") ?: "unsb-sk-test0-vault-unlck-12345"")
        .get()
        .build()

    client.newCall(statusRequest).execute().use { response ->
        val status = JSONObject(response.body!!.string())

        when (status.getString("status")) {
            "completed" -> {
                val result = status.getJSONObject("result")
                if (result.getBoolean("success")) {
                    println("Output: ${result.getString("stdout")}")
                } else {
                    println("Error: ${result.getString("stderr")}")
                }
                break
            }
            "timeout", "cancelled" -> {
                println("Job ${status.getString("status")}")
                break
            }
        }
    }

    Thread.sleep(1000)
}

Initial Response

{
  "job_id": "job_1234567890_abc",
  "status": "pending"
}

Check the status and results of an asynchronous job. Poll this endpoint after submitting a job via /execute/async or /run/async.

URL Parameters

Example (Kotlin)

import okhttp3.OkHttpClient
import okhttp3.Request
import org.json.JSONObject

val client = OkHttpClient()
val jobId = "job_1234567890_abc"

val request = Request.Builder()
    .url("https://api.unsandbox.com/jobs/$jobId")
    .addHeader("Authorization", "Bearer System.getenv("UNSANDBOX_API_KEY") ?: "unsb-sk-test0-vault-unlck-12345"")
    .get()
    .build()

client.newCall(request).execute().use { response ->
    val job = JSONObject(response.body!!.string())

    println("Status: ${job.getString("status")}")
    if (job.getString("status") == "completed") {
        val result = job.getJSONObject("result")
        println("Success: ${result.getBoolean("success")}")
        println("Output: ${result.getString("stdout")}")
    }
}

Response (Completed)

{
  "job_id": "job_1234567890_abc",
  "status": "completed",
  "result": {
    "success": true,
    "stdout": "Hello from unsandbox!\n",
    "stderr": "",
    "error": null,
    "language": "python",
    "exit_code": 0
  }
}

Possible Status Values

• pending - Job queued, waiting to execute
• running - Job currently executing
• completed - Job finished (check result field)
• timeout - Job exceeded TTL limit
• cancelled - Job was cancelled via DELETE

List all active (pending or running) jobs for your API key. Useful for monitoring multiple async executions.

Example (Kotlin)

import okhttp3.OkHttpClient
import okhttp3.Request
import org.json.JSONArray

val client = OkHttpClient()

val request = Request.Builder()
    .url("https://api.unsandbox.com/jobs")
    .addHeader("Authorization", "Bearer System.getenv("UNSANDBOX_API_KEY") ?: "unsb-sk-test0-vault-unlck-12345"")
    .get()
    .build()

client.newCall(request).execute().use { response ->
    val jobs = JSONArray(response.body!!.string())

    for (i in 0 until jobs.length()) {
        val job = jobs.getJSONObject(i)
        println("${job.getString("job_id")}: ${job.getString("status")} (${job.getString("language")})")
    }
}

Response

{
  "jobs": [
    {
      "job_id": "job_1234567890_abc",
      "status": "running",
      "language": "python",
      "submitted_at": "2024-01-15T10:30:00Z"
    },
    {
      "job_id": "job_0987654321_xyz",
      "status": "pending",
      "language": "go",
      "submitted_at": "2024-01-15T10:29:45Z"
    }
  ]
}

Cancel a pending or running job. If the job is already executing, it will be terminated and partial output returned.

URL Parameters

Example (Kotlin)

import okhttp3.OkHttpClient
import okhttp3.Request
import org.json.JSONObject

val client = OkHttpClient()
val jobId = "job_1234567890_abc"

val request = Request.Builder()
    .url("https://api.unsandbox.com/jobs/$jobId")
    .addHeader("Authorization", "Bearer System.getenv("UNSANDBOX_API_KEY") ?: "unsb-sk-test0-vault-unlck-12345"")
    .delete()
    .build()

client.newCall(request).execute().use { response ->
    val result = JSONObject(response.body!!.string())

    println("Cancelled: ${result.getString("message")}")
    if (result.has("stdout")) {
        println("Partial output: ${result.getJSONObject("result").getString("stdout")}")
    }
}

Response

{
  "message": "Job cancelled",
  "job_id": "job_1234567890_abc",
  "result": {
    "success": false,
    "stdout": "Partial output before cancel...",
    "stderr": "",
    "error": "Job cancelled by user",
    "exit_code": -1
  }
}

Execute code with automatic language detection via shebang. Send raw code as the request body with Content-Type: text/plain.

Request

• Content-Type: text/plain
• Body: Raw code with shebang (e.g., #!/usr/bin/env python3)

Query Parameters

Example (Kotlin)

import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject

val client = OkHttpClient()
val mediaType = "text/plain".toMediaType()

val code = """#!/usr/bin/env python3
print("Language auto-detected!")"""

val request = Request.Builder()
    .url("https://api.unsandbox.com/run")
    .addHeader("Content-Type", "text/plain")
    .addHeader("Authorization", "Bearer System.getenv("UNSANDBOX_API_KEY") ?: "unsb-sk-test0-vault-unlck-12345"")
    .post(code.toRequestBody(mediaType))
    .build()

client.newCall(request).execute().use { response ->
    val result = JSONObject(response.body!!.string())

    println("Detected: ${result.getString("detected_language")}")
    println("Output: ${result.getString("stdout")}")
}

Response

{
  "success": true,
  "stdout": "Language auto-detected!\n",
  "stderr": "",
  "error": null,
  "detected_language": "python",
  "exit_code": 0
}

Submit code with automatic language detection and receive a job ID. Combines the convenience of /run with the flexibility of async execution.

Request

• Content-Type: text/plain
• Body: Raw code with shebang (e.g., #!/usr/bin/env ruby)

Query Parameters

Example (Kotlin)

import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject

val client = OkHttpClient()
val mediaType = "text/plain".toMediaType()

val code = """#!/usr/bin/env ruby
puts "Running async with auto-detect!" """

// Submit job
val request = Request.Builder()
    .url("https://api.unsandbox.com/run/async")
    .addHeader("Content-Type", "text/plain")
    .addHeader("Authorization", "Bearer System.getenv("UNSANDBOX_API_KEY") ?: "unsb-sk-test0-vault-unlck-12345"")
    .post(code.toRequestBody(mediaType))
    .build()

val jobId = client.newCall(request).execute().use { response ->
    JSONObject(response.body!!.string()).getString("job_id")
}

println("Job submitted: $jobId")

// Poll for results
while (true) {
    val statusRequest = Request.Builder()
        .url("https://api.unsandbox.com/jobs/$jobId")
        .addHeader("Authorization", "Bearer System.getenv("UNSANDBOX_API_KEY") ?: "unsb-sk-test0-vault-unlck-12345"")
        .get()
        .build()

    client.newCall(statusRequest).execute().use { response ->
        val status = JSONObject(response.body!!.string())

        when (status.getString("status")) {
            "completed" -> {
                val result = status.getJSONObject("result")
                println("Detected: ${result.getString("detected_language")}")
                if (result.getBoolean("success")) {
                    println("Output: ${result.getString("stdout")}")
                }
                break
            }
            "timeout", "cancelled" -> {
                println("Job ${status.getString("status")}")
                break
            }
        }
    }

    Thread.sleep(1000)
}

Initial Response

{
  "job_id": "job_1234567890_abc",
  "status": "pending"
}

Job Result (via GET /jobs/{id})

{
  "job_id": "job_1234567890_abc",
  "status": "completed",
  "result": {
    "success": true,
    "stdout": "Running async with auto-detect!\n",
    "stderr": "",
    "error": null,
    "detected_language": "ruby",
    "exit_code": 0
  }
}