unsandbox.com

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

Request Parameters

Example (Clojure)

(ns unsandbox.example
  (:require [clj-http.client :as client]
            [cheshire.core :as json]))

(def api-key (or (System/getenv "UNSANDBOX_API_KEY") "unsb-sk-test0-vault-unlck-12345"))

(defn execute-code []
  (let [response (client/post "https://api.unsandbox.com/execute"
                              {:headers {"Authorization" (str "Bearer " api-key)
                                        "Content-Type" "application/json"}
                               :body (json/generate-string
                                      {:language "clojure"
                                       :code "(println \"Hello from unsandbox!\")"})})]
    (println (json/parse-string (:body response) true))))

(execute-code)

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

(ns unsandbox.example
  (:require [clj-http.client :as client]
            [cheshire.core :as json]))

(def api-key (or (System/getenv "UNSANDBOX_API_KEY") "unsb-sk-test0-vault-unlck-12345"))

(defn execute-async []
  (let [code "(defn factorial [n]
  (if (<= n 1)
    1
    (* n (factorial (dec n)))))

(println \"Computing factorial...\")
(println (factorial 20))"
        response (client/post "https://api.unsandbox.com/execute/async"
                              {:headers {"Authorization" (str "Bearer " api-key)
                                        "Content-Type" "application/json"}
                               :body (json/generate-string
                                      {:language "clojure"
                                       :code code
                                       :ttl 300})})]
    (println (json/parse-string (:body response) true))))

(execute-async)

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

(require '[clj-http.client :as client])
(require '[cheshire.core :as json])

(def api-key (or (System/getenv "UNSANDBOX_API_KEY") "unsb-sk-test0-vault-unlck-12345"))

(defn get-job [job-id]
  (let [response (client/get (str "https://api.unsandbox.com/jobs/" job-id)
                             {:headers {"Authorization" (str "Bearer " api-key)}})]
    (println (json/parse-string (:body response) true))))

(get-job "job_1234567890_abc")

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

(ns unsandbox.example
  (:require [clj-http.client :as client]
            [cheshire.core :as json]))

(def api-key (or (System/getenv "UNSANDBOX_API_KEY") "unsb-sk-test0-vault-unlck-12345"))

(defn list-jobs []
  (let [response (client/get "https://api.unsandbox.com/jobs"
                             {:headers {"Authorization" (str "Bearer " api-key)}})]
    (println (json/parse-string (:body response) true))))

(list-jobs)

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

(require '[clj-http.client :as client])
(require '[cheshire.core :as json])

(def api-key (or (System/getenv "UNSANDBOX_API_KEY") "unsb-sk-test0-vault-unlck-12345"))

(defn delete-job [job-id]
  (let [response (client/delete (str "https://api.unsandbox.com/jobs/" job-id)
                                {:headers {"Authorization" (str "Bearer " api-key)}})]
    (println (json/parse-string (:body response) true))))

(delete-job "job_1234567890_abc")

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

(ns unsandbox.example
  (:require [clj-http.client :as client]
            [cheshire.core :as json]))

(def api-key (or (System/getenv "UNSANDBOX_API_KEY") "unsb-sk-test0-vault-unlck-12345"))

(defn run-code []
  (let [response (client/post "https://api.unsandbox.com/run"
                              {:headers {"Authorization" (str "Bearer " api-key)
                                        "Content-Type" "text/plain"}
                               :body "(println \"Language auto-detected!\")"})]
    (println (json/parse-string (:body response) true))))

(run-code)

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

(ns unsandbox.example
  (:require [clj-http.client :as client]
            [cheshire.core :as json]))

(def api-key (or (System/getenv "UNSANDBOX_API_KEY") "unsb-sk-test0-vault-unlck-12345"))

(defn run-async []
  (let [code "(println \"Running async with auto-detect!\")
(println (reduce + (range 1 1000001)))"
        response (client/post "https://api.unsandbox.com/run/async"
                              {:headers {"Authorization" (str "Bearer " api-key)
                                        "Content-Type" "text/plain"}
                               :body code})]
    (println (json/parse-string (:body response) true))))

(run-async)

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