unsandbox.com

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

Request Parameters

Example (Crystal)

require "http/client"
require "json"

client = HTTP::Client.new("api.unsandbox.com", tls: true)
api_key = ENV["UNSANDBOX_API_KEY"]? || "unsb-sk-test0-vault-unlck-12345"
headers = HTTP::Headers{
  "Content-Type"  => "application/json",
  "Authorization" => "Bearer #{api_key}",
}

payload = {
  language: "crystal",
  code:     "puts \"Hello from unsandbox!\"",
}.to_json

response = client.post("/execute", headers: headers, body: payload)
result = JSON.parse(response.body)

if result["success"].as_bool
  puts "Output: #{result["stdout"]}"
else
  puts "Error: #{result["error"]}"
end

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 (Crystal)

require "http/client"
require "json"

client = HTTP::Client.new("api.unsandbox.com", tls: true)
api_key = ENV["UNSANDBOX_API_KEY"]? || "unsb-sk-test0-vault-unlck-12345"
headers = HTTP::Headers{
  "Content-Type"  => "application/json",
  "Authorization" => "Bearer #{api_key}",
}

# Submit job
payload = {
  language: "rust",
  code:     "fn main() { println!(\"Computing...\"); }",
  ttl:      300,
}.to_json

response = client.post("/execute/async", headers: headers, body: payload)
job = JSON.parse(response.body)
job_id = job["job_id"].as_s

puts "Job submitted: #{job_id}"

# Wait briefly for job to be created
sleep 2

# Poll for results
loop do
  response = client.get("/jobs/#{job_id}", headers: headers)

  if response.status_code != 200
    puts "Error checking job status: #{response.status_code}"
    break
  end

  status = JSON.parse(response.body)
  state = status["status"]?.try(&.as_s)

  case state
  when "completed"
    exit_code = status["exit_code"]?.try(&.as_i) || 1
    if exit_code == 0
      puts "Output: #{status["stdout"]?}"
    else
      puts "Error: #{status["stderr"]?}"
    end
    break
  when "timeout", "cancelled"
    puts "Job #{state}"
    break
  end

  sleep 1
end

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 (Crystal)

require "http/client"
require "json"

client = HTTP::Client.new("api.unsandbox.com", tls: true)
api_key = ENV["UNSANDBOX_API_KEY"]? || "unsb-sk-test0-vault-unlck-12345"
headers = HTTP::Headers{
  "Content-Type" => "application/json",
  "Authorization" => "Bearer #{api_key}",
}

# Submit a job to get a real job ID
payload = {
  "language" => "python",
  "code" => "print('Example job')"
}.to_json

submit_response = client.post("/execute/async", headers: headers, body: payload)
job_data = JSON.parse(submit_response.body)
job_id = job_data["job_id"].as_s

puts "Submitted job: #{job_id}"

# Get job status
status_headers = HTTP::Headers{
  "Authorization" => "Bearer #{api_key}",
}

response = client.get("/jobs/#{job_id}", headers: status_headers)

if response.status_code == 200
  job = JSON.parse(response.body)
  puts "Status: #{job["status"]?}"
  if job["status"]?.try(&.as_s) == "completed"
    puts "Exit code: #{job["exit_code"]?}"
    puts "Output: #{job["stdout"]?}"
  end
elsif response.status_code == 404
  puts "Job not found"
else
  puts "Error: #{response.status_code}"
end

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 (Crystal)

require "http/client"
require "json"

client = HTTP::Client.new("api.unsandbox.com", tls: true)
api_key = ENV["UNSANDBOX_API_KEY"]? || "unsb-sk-test0-vault-unlck-12345"
headers = HTTP::Headers{
  "Authorization" => "Bearer #{api_key}",
}

response = client.get("/jobs", headers: headers)
jobs = JSON.parse(response.body).as_a

jobs.each do |job|
  puts "#{job["job_id"]}: #{job["status"]} (#{job["language"]})"
end

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 (Crystal)

require "http/client"
require "json"

client = HTTP::Client.new("api.unsandbox.com", tls: true)
api_key = ENV["UNSANDBOX_API_KEY"]? || "unsb-sk-test0-vault-unlck-12345"
headers = HTTP::Headers{
  "Content-Type" => "application/json",
  "Authorization" => "Bearer #{api_key}",
}

# Submit a long-running job to demonstrate cancellation
payload = {
  "language" => "python",
  "code" => "import time; time.sleep(10); print('Done')"
}.to_json

submit_response = client.post("/execute/async", headers: headers, body: payload)
job_data = JSON.parse(submit_response.body)
job_id = job_data["job_id"].as_s

puts "Submitted job: #{job_id}"

# Delete/cancel the job
delete_headers = HTTP::Headers{
  "Authorization" => "Bearer #{api_key}",
}

response = client.delete("/jobs/#{job_id}", headers: delete_headers)

if response.status_code == 200
  result = JSON.parse(response.body)
  puts "Cancelled: #{result["message"]? || "Job cancelled"}"
  if result["stdout"]?
    puts "Partial output: #{result["stdout"]?}"
  end
elsif response.status_code == 404
  puts "Job not found or already deleted"
else
  puts "Error: #{response.status_code}"
end

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 (Crystal)

require "http/client"
require "json"

client = HTTP::Client.new("api.unsandbox.com", tls: true)
api_key = ENV["UNSANDBOX_API_KEY"]? || "unsb-sk-test0-vault-unlck-12345"
headers = HTTP::Headers{
  "Content-Type"  => "text/plain",
  "Authorization" => "Bearer #{api_key}",
}

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

response = client.post("/run", headers: headers, body: code)
result = JSON.parse(response.body)

puts "Detected: #{result["detected_language"]}"
puts "Output: #{result["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 (Crystal)

require "http/client"
require "json"

client = HTTP::Client.new("api.unsandbox.com", tls: true)
api_key = ENV["UNSANDBOX_API_KEY"]? || "unsb-sk-test0-vault-unlck-12345"
headers = HTTP::Headers{
  "Content-Type"  => "text/plain",
  "Authorization" => "Bearer #{api_key}",
}

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

# Submit job
response = client.post("/run/async", headers: headers, body: code)
job = JSON.parse(response.body)
job_id = job["job_id"].as_s

puts "Job submitted: #{job_id}"

# Wait briefly for job to be created
sleep 2

# Poll for results
loop do
  response = client.get("/jobs/#{job_id}", headers: headers)

  if response.status_code != 200
    puts "Error checking job status: #{response.status_code}"
    break
  end

  status = JSON.parse(response.body)
  state = status["status"]?.try(&.as_s)

  case state
  when "completed"
    puts "Detected: #{status["detected_language"]?}"
    exit_code = status["exit_code"]?.try(&.as_i) || 1
    if exit_code == 0
      puts "Output: #{status["stdout"]?}"
    end
    break
  when "timeout", "cancelled"
    puts "Job #{state}"
    break
  end

  sleep 1
end

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
  }
}