unsandbox.com

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

Request Parameters

Example (Elixir)

# Requires Jason package for JSON parsing (already installed in container)
:inets.start()
:ssl.start()

url = ~c"https://api.unsandbox.com/execute"
headers = [
  {~c"Content-Type", ~c"application/json"},
  {~c"Authorization", ~c"Bearer #{ System.get_env("UNSANDBOX_API_KEY", "unsb-sk-test0-vault-unlck-12345") }"}
]
body = ~S({"language":"python","code":"print('Hello from unsandbox!')"})

case :httpc.request(:post, {url, headers, ~c"application/json", body}, [], []) do
  {:ok, {{_, 200, _}, _, response}} ->
    result = Jason.decode!(to_string(response))
    exit_code = Map.get(result, "exit_code", 1)

    if exit_code == 0 do
      IO.puts("Output: #{Map.get(result, "stdout")}")
    else
      IO.puts("Error: #{Map.get(result, "stderr")}")
    end
  {:error, reason} ->
    IO.puts("Request failed: #{inspect(reason)}")
end

Response (Success)

{
  "success": true,
  "stdout": "Hello from unsandbox!\n",
  "stderr": "",
  "exit_code": 0,
  "language": "python",
  "job_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "artifacts": [],
  "execution_mode": "pooled",
  "network_mode": "zerotrust",
  "total_time_ms": 523
}

Response (Error)

{
  "success": false,
  "stdout": "",
  "stderr": "SyntaxError: invalid syntax\n",
  "exit_code": 1,
  "language": "python",
  "job_id": "b2c3d4e5-f6a7-8901-bcde-f23456789012",
  "artifacts": [],
  "execution_mode": "pooled",
  "network_mode": "zerotrust",
  "total_time_ms": 312
}

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

# Requires Jason package for JSON parsing (already installed in container)
:inets.start()
:ssl.start()

# Submit job
url = ~c"https://api.unsandbox.com/execute/async"
headers = [
  {~c"Content-Type", ~c"application/json"},
  {~c"Authorization", ~c"Bearer #{ System.get_env("UNSANDBOX_API_KEY", "unsb-sk-test0-vault-unlck-12345") }"}
]
body = ~S({"language":"rust","code":"fn main() { println!(\"Computing...\"); }","ttl":300})

{:ok, {{_, 200, _}, _, response}} = :httpc.request(:post, {url, headers, ~c"application/json", body}, [], [])
job = Jason.decode!(to_string(response))
job_id = Map.get(job, "job_id")

IO.puts("Job submitted: #{job_id}")

# Poll for results
defmodule JobPoller do
  def poll(job_id, headers) do
    status_url = ~c"https://api.unsandbox.com/jobs/#{job_id}"
    {:ok, {{_, 200, _}, _, response}} = :httpc.request(:get, {status_url, headers}, [], [])
    status = Jason.decode!(to_string(response))

    case Map.get(status, "status") do
      "completed" ->
        result = Map.get(status, "result")
        exit_code = Map.get(result, "exit_code", 1)

        if exit_code == 0 do
          IO.puts("Output: #{Map.get(result, "stdout")}")
        else
          IO.puts("Error: #{Map.get(result, "stderr")}")
        end
      status when status in ["timeout", "cancelled"] ->
        IO.puts("Job #{status}")
      _ ->
        Process.sleep(1000)
        poll(job_id, headers)
    end
  end
end

JobPoller.poll(job_id, headers)

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

Mix.install([{:jason, "~> 1.4"}])

:inets.start()
:ssl.start()

job_id = "job_1234567890_abc"
url = ~c"https://api.unsandbox.com/jobs/#{job_id}"

headers = [
  {~c"Authorization",
   ~c"Bearer #{System.get_env("UNSANDBOX_API_KEY", "unsb-sk-test0-vault-unlck-12345")}"}
]

case :httpc.request(:get, {url, headers}, [], []) do
  {:ok, {{_, 200, _}, _, response}} ->
    job = Jason.decode!(to_string(response))
    IO.puts("Status: #{Map.get(job, "status")}")

    if Map.get(job, "status") == "completed" do
      result = Map.get(job, "result")
      exit_code = Map.get(result, "exit_code", 1)
      IO.puts("Exit code: #{exit_code}")
      IO.puts("Output: #{Map.get(result, "stdout")}")
    end

  {:ok, {{_, 404, _}, _, _}} ->
    IO.puts("Job not found")

  {:error, reason} ->
    IO.puts("Request failed: #{inspect(reason)}")
end

Response (Completed)

{
  "job_id": "c3d4e5f6-a7b8-9012-cdef-345678901234",
  "status": "completed",
  "created_at": 1699564800,
  "started_at": 1699564801,
  "completed_at": 1699564805,
  "result": {
    "success": true,
    "stdout": "Hello from unsandbox!\n",
    "stderr": "",
    "exit_code": 0,
    "language": "python",
    "artifacts": [],
    "execution_mode": "pooled",
    "network_mode": "zerotrust",
    "total_time_ms": 4021
  }
}

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

Mix.install([{:jason, "~> 1.4"}])

:inets.start()
:ssl.start()

url = ~c"https://api.unsandbox.com/jobs"

headers = [
  {~c"Authorization",
   ~c"Bearer #{System.get_env("UNSANDBOX_API_KEY", "unsb-sk-test0-vault-unlck-12345")}"}
]

case :httpc.request(:get, {url, headers}, [], []) do
  {:ok, {{_, 200, _}, _, response}} ->
    jobs = Jason.decode!(to_string(response))

    Enum.each(jobs, fn job ->
      IO.puts(
        "#{Map.get(job, "job_id")}: #{Map.get(job, "status")} (#{Map.get(job, "language")})"
      )
    end)

  {:error, reason} ->
    IO.puts("Request failed: #{inspect(reason)}")
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 (Elixir)

Mix.install([{:jason, "~> 1.4"}])

:inets.start()
:ssl.start()

job_id = "job_1234567890_abc"
url = ~c"https://api.unsandbox.com/jobs/#{job_id}"

headers = [
  {~c"Authorization",
   ~c"Bearer #{System.get_env("UNSANDBOX_API_KEY", "unsb-sk-test0-vault-unlck-12345")}"}
]

case :httpc.request(:delete, {url, headers}, [], []) do
  {:ok, {{_, 200, _}, _, response}} ->
    result = Jason.decode!(to_string(response))
    IO.puts("Cancelled: #{Map.get(result, "message")}")

    if Map.has_key?(result, "result") do
      IO.puts("Partial output: #{Map.get(Map.get(result, "result"), "stdout")}")
    end

  {:ok, {{_, 404, _}, _, _}} ->
    IO.puts("Job not found or already deleted")

  {:error, reason} ->
    IO.puts("Request failed: #{inspect(reason)}")
end

Response

{
  "message": "Job cancelled",
  "job_id": "e5f6a7b8-c9d0-1234-efgh-567890123456",
  "result": {
    "success": false,
    "stdout": "Partial output before cancel...",
    "stderr": "",
    "exit_code": -1,
    "language": "python",
    "artifacts": [],
    "execution_mode": "pooled",
    "network_mode": "zerotrust",
    "total_time_ms": 1523
  }
}

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

# Requires Jason package for JSON parsing (already installed in container)
:inets.start()
:ssl.start()

url = ~c"https://api.unsandbox.com/run"

headers = [
  {~c"Content-Type", ~c"text/plain"},
  {~c"Authorization",
   ~c"Bearer #{System.get_env("UNSANDBOX_API_KEY", "unsb-sk-test0-vault-unlck-12345")}"}
]

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

case :httpc.request(:post, {url, headers, ~c"text/plain", code}, [], []) do
  {:ok, {{_, 200, _}, _, response}} ->
    result = Jason.decode!(to_string(response))
    IO.puts("Detected: #{Map.get(result, "detected_language")}")
    IO.puts("Output: #{Map.get(result, "stdout")}")

  {:error, reason} ->
    IO.puts("Request failed: #{inspect(reason)}")
end

Response

{
  "success": true,
  "stdout": "Language auto-detected!\n",
  "stderr": "",
  "exit_code": 0,
  "language": "python",
  "detected_language": "python",
  "job_id": "f6a7b8c9-d0e1-2345-fghi-678901234567",
  "artifacts": [],
  "execution_mode": "pooled",
  "network_mode": "zerotrust",
  "total_time_ms": 412
}

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

# Requires Jason package for JSON parsing (already installed in container)
:inets.start()
:ssl.start()

# Submit job
url = ~c"https://api.unsandbox.com/run/async"

headers = [
  {~c"Content-Type", ~c"text/plain"},
  {~c"Authorization",
   ~c"Bearer #{System.get_env("UNSANDBOX_API_KEY", "unsb-sk-test0-vault-unlck-12345")}"}
]

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

{:ok, {{_, 200, _}, _, response}} =
  :httpc.request(:post, {url, headers, ~c"text/plain", code}, [], [])

job = Jason.decode!(to_string(response))
job_id = Map.get(job, "job_id")

IO.puts("Job submitted: #{job_id}")

# Poll for results
defmodule JobPoller do
  def poll(job_id, headers) do
    status_url = ~c"https://api.unsandbox.com/jobs/#{job_id}"
    {:ok, {{_, 200, _}, _, response}} = :httpc.request(:get, {status_url, headers}, [], [])
    status = Jason.decode!(to_string(response))

    case Map.get(status, "status") do
      "completed" ->
        result = Map.get(status, "result")
        exit_code = Map.get(result, "exit_code", 1)
        IO.puts("Detected: #{Map.get(result, "detected_language")}")

        if exit_code == 0 do
          IO.puts("Output: #{Map.get(result, "stdout")}")
        end

      status when status in ["timeout", "cancelled"] ->
        IO.puts("Job #{status}")

      _ ->
        Process.sleep(1000)
        poll(job_id, headers)
    end
  end
end

JobPoller.poll(job_id, headers)

Initial Response

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

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

{
  "job_id": "a7b8c9d0-e1f2-3456-ghij-789012345678",
  "status": "completed",
  "created_at": 1699564800,
  "started_at": 1699564801,
  "completed_at": 1699564802,
  "result": {
    "success": true,
    "stdout": "Running async with auto-detect!\n",
    "stderr": "",
    "exit_code": 0,
    "language": "ruby",
    "detected_language": "ruby",
    "artifacts": [],
    "execution_mode": "pooled",
    "network_mode": "zerotrust",
    "total_time_ms": 1234
  }
}

Upload files to your sandbox execution. Files are written to the working directory and can be accessed directly by filename.

File Object Schema

Example Request

{
  "language": "python",
  "code": "print(open('data.csv').read())",
  "input_files": [
    {
      "filename": "data.csv",
      "content": "bmFtZSxhZ2UKQWxpY2UsMzAKQm9iLDI1"
    }
  ]
}

Limits

• Maximum files: 10 files per execution
• Maximum total size: 10MB (decoded)
• Maximum single file: 5MB (decoded)
• Filename length: 256 characters max

File Access

Files are placed in the working directory. Access them directly:

• Python: open('data.csv')
• Node.js: fs.readFileSync('data.csv')
• Ruby: File.read('data.csv')
• Go: os.ReadFile("data.csv")

Security

• Files are isolated per execution
• Filenames cannot contain path separators (no / or ..)
• Files are deleted after execution completes