unsandbox.com

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

Request Parameters

Example (Go)

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

func getAPIKey() string {
	if key := os.Getenv("UNSANDBOX_API_KEY"); key != "" {
		return key
	}
	return "unsb-sk-test0-vault-unlck-12345"
}

func main() {
	url := "https://api.unsandbox.com/execute"
	payload := map[string]string{
		"language": "python",
		"code":     "print('Hello from unsandbox!')",
	}

	jsonData, err := json.Marshal(payload)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error marshaling JSON: %v\n", err)
		os.Exit(1)
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error creating request: %v\n", err)
		os.Exit(1)
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+getAPIKey())

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error making request: %v\n", err)
		os.Exit(1)
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		fmt.Fprintf(os.Stderr, "API returned status: %d\n", resp.StatusCode)
		os.Exit(1)
	}

	var result map[string]interface{}
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		fmt.Fprintf(os.Stderr, "Error decoding response: %v\n", err)
		os.Exit(1)
	}

	exitCode, ok := result["exit_code"].(float64)
	if !ok {
		fmt.Fprintf(os.Stderr, "Error: exit_code field missing or invalid\n")
		os.Exit(1)
	}

	if exitCode == 0 {
		if stdout, ok := result["stdout"].(string); ok {
			fmt.Println("Output:", stdout)
		}
	} else {
		if stderr, ok := result["stderr"].(string); ok {
			fmt.Println("Error:", stderr)
		}
	}
}

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

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"time"
)

func getAPIKey() string {
	if key := os.Getenv("UNSANDBOX_API_KEY"); key != "" {
		return key
	}
	return "unsb-sk-test0-vault-unlck-12345"
}

func main() {
	// Submit job
	url := "https://api.unsandbox.com/execute/async"
	payload := map[string]interface{}{
		"language": "python",
		"code":     "print('Computing...')",
		"ttl":      300,
	}

	jsonData, err := json.Marshal(payload)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error marshaling JSON: %v\n", err)
		os.Exit(1)
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error creating request: %v\n", err)
		os.Exit(1)
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+getAPIKey())

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error making request: %v\n", err)
		os.Exit(1)
	}
	defer resp.Body.Close()

	var job map[string]interface{}
	if err := json.NewDecoder(resp.Body).Decode(&job); err != nil {
		fmt.Fprintf(os.Stderr, "Error decoding response: %v\n", err)
		os.Exit(1)
	}

	jobID, ok := job["job_id"].(string)
	if !ok {
		fmt.Fprintf(os.Stderr, "Error: job_id field missing or invalid\n")
		os.Exit(1)
	}

	fmt.Printf("Job submitted: %s\n", jobID)

	// Wait briefly for job to be created
	time.Sleep(2 * time.Second)

	// Poll for results
	statusURL := fmt.Sprintf("https://api.unsandbox.com/jobs/%s", jobID)
	maxAttempts := 20
	for attempts := 0; attempts < maxAttempts; attempts++ {
		req, err := http.NewRequest("GET", statusURL, nil)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Error creating status request: %v\n", err)
			os.Exit(1)
		}
		req.Header.Set("Authorization", "Bearer "+getAPIKey())

		resp, err := client.Do(req)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Error fetching status: %v\n", err)
			os.Exit(1)
		}

		var status map[string]interface{}
		if err := json.NewDecoder(resp.Body).Decode(&status); err != nil {
			resp.Body.Close()
			fmt.Fprintf(os.Stderr, "Error decoding status: %v\n", err)
			os.Exit(1)
		}
		resp.Body.Close()

		if status["status"] == "completed" {
			exitCode, ok := status["exit_code"].(float64)
			if !ok {
				fmt.Fprintf(os.Stderr, "Error: exit_code field missing or invalid\n")
				os.Exit(1)
			}

			if exitCode == 0 {
				if stdout, ok := status["stdout"].(string); ok {
					fmt.Println("Output:", stdout)
				}
			} else {
				if stderr, ok := status["stderr"].(string); ok {
					fmt.Println("Error:", stderr)
				}
			}
			break
		} else if status["status"] == "timeout" || status["status"] == "cancelled" {
			fmt.Printf("Job %s\n", status["status"])
			break
		}

		time.Sleep(1 * time.Second) // Wait 1 second before polling again
	}
}

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

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

func getAPIKey() string {
	if key := os.Getenv("UNSANDBOX_API_KEY"); key != "" {
		return key
	}
	return "unsb-sk-test0-vault-unlck-12345"
}

func main() {
	jobID := "job_1234567890_abc"
	url := fmt.Sprintf("https://api.unsandbox.com/jobs/%s", jobID)

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error creating request: %v\n", err)
		os.Exit(1)
	}
	req.Header.Set("Authorization", "Bearer "+getAPIKey())

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error making request: %v\n", err)
		os.Exit(1)
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		fmt.Fprintf(os.Stderr, "Request failed with status: %d\n", resp.StatusCode)
		os.Exit(1)
	}

	var job map[string]interface{}
	if err := json.NewDecoder(resp.Body).Decode(&job); err != nil {
		fmt.Fprintf(os.Stderr, "Error decoding response: %v\n", err)
		os.Exit(1)
	}

	status, ok := job["status"].(string)
	if !ok {
		fmt.Fprintf(os.Stderr, "Error: status field missing or invalid\n")
		os.Exit(1)
	}

	fmt.Printf("Status: %s\n", status)
	if status == "completed" {
		if success, ok := job["success"].(bool); ok {
			fmt.Printf("Success: %v\n", success)
		}

		if stdout, ok := job["stdout"].(string); ok {
			fmt.Printf("Output: %s\n", stdout)
		}
	}
}

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

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

func getAPIKey() string {
	if key := os.Getenv("UNSANDBOX_API_KEY"); key != "" {
		return key
	}
	return "unsb-sk-test0-vault-unlck-12345"
}

func main() {
	url := "https://api.unsandbox.com/jobs"

	req, _ := http.NewRequest("GET", url, nil)
	req.Header.Set("Authorization", "Bearer "+getAPIKey())

	client := &http.Client{}
	resp, _ := client.Do(req)
	defer resp.Body.Close()

	var jobs []map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&jobs)

	for _, job := range jobs {
		fmt.Printf("%s: %s (%s)\n", job["job_id"], job["status"], job["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 (Go)

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

func getAPIKey() string {
	if key := os.Getenv("UNSANDBOX_API_KEY"); key != "" {
		return key
	}
	return "unsb-sk-test0-vault-unlck-12345"
}

func main() {
	jobID := "job_1234567890_abc"
	url := fmt.Sprintf("https://api.unsandbox.com/jobs/%s", jobID)

	req, _ := http.NewRequest("DELETE", url, nil)
	req.Header.Set("Authorization", "Bearer "+getAPIKey())

	client := &http.Client{}
	resp, _ := client.Do(req)
	defer resp.Body.Close()

	var result map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&result)

	fmt.Printf("Cancelled: %s\n", result["message"])
	if result["stdout"] != nil {
		fmt.Printf("Partial output: %s\n", result["stdout"])
	}
}

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

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

func getAPIKey() string {
	if key := os.Getenv("UNSANDBOX_API_KEY"); key != "" {
		return key
	}
	return "unsb-sk-test0-vault-unlck-12345"
}

func main() {
	url := "https://api.unsandbox.com/run"
	code := `#!/usr/bin/env python3
print("Language auto-detected!")`

	req, _ := http.NewRequest("POST", url, bytes.NewBufferString(code))
	req.Header.Set("Content-Type", "text/plain")
	req.Header.Set("Authorization", "Bearer "+getAPIKey())

	client := &http.Client{}
	resp, _ := client.Do(req)
	defer resp.Body.Close()

	var result map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&result)

	fmt.Printf("Detected: %s\n", result["detected_language"])
	fmt.Printf("Output: %s\n", result["stdout"])
}

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

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"time"
)

func getAPIKey() string {
	if key := os.Getenv("UNSANDBOX_API_KEY"); key != "" {
		return key
	}
	return "unsb-sk-test0-vault-unlck-12345"
}

func main() {
	url := "https://api.unsandbox.com/run/async"
	code := `#!/usr/bin/env ruby
puts "Running async with auto-detect!"`

	// Submit job
	req, err := http.NewRequest("POST", url, bytes.NewBufferString(code))
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error creating request: %v\n", err)
		os.Exit(1)
	}
	req.Header.Set("Content-Type", "text/plain")
	req.Header.Set("Authorization", "Bearer "+getAPIKey())

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error making request: %v\n", err)
		os.Exit(1)
	}

	var job map[string]interface{}
	if err := json.NewDecoder(resp.Body).Decode(&job); err != nil {
		resp.Body.Close()
		fmt.Fprintf(os.Stderr, "Error decoding response: %v\n", err)
		os.Exit(1)
	}
	resp.Body.Close()

	jobID, ok := job["job_id"].(string)
	if !ok {
		fmt.Fprintf(os.Stderr, "Error: job_id field missing or invalid\n")
		os.Exit(1)
	}
	fmt.Printf("Job submitted: %s\n", jobID)

	// Wait briefly for job to be created
	time.Sleep(2 * time.Second)

	// Poll for results
	statusURL := fmt.Sprintf("https://api.unsandbox.com/jobs/%s", jobID)
	maxAttempts := 20
	for attempts := 0; attempts < maxAttempts; attempts++ {
		req, err := http.NewRequest("GET", statusURL, nil)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Error creating status request: %v\n", err)
			os.Exit(1)
		}
		req.Header.Set("Authorization", "Bearer "+getAPIKey())

		resp, err := client.Do(req)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Error fetching status: %v\n", err)
			os.Exit(1)
		}

		var status map[string]interface{}
		if err := json.NewDecoder(resp.Body).Decode(&status); err != nil {
			resp.Body.Close()
			fmt.Fprintf(os.Stderr, "Error decoding status: %v\n", err)
			os.Exit(1)
		}
		resp.Body.Close()

		if status["status"] == "completed" {
			if detectedLang, ok := status["detected_language"].(string); ok {
				fmt.Printf("Detected: %s\n", detectedLang)
			}

			exitCode, ok := status["exit_code"].(float64)
			if !ok {
				fmt.Fprintf(os.Stderr, "Error: exit_code field missing or invalid\n")
				os.Exit(1)
			}

			if exitCode == 0 {
				if stdout, ok := status["stdout"].(string); ok {
					fmt.Printf("Output: %s\n", stdout)
				}
			} else {
				if stderr, ok := status["stderr"].(string); ok {
					fmt.Printf("Error: %s\n", stderr)
				}
			}
			break
		} else if status["status"] == "timeout" || status["status"] == "cancelled" {
			fmt.Printf("Job %s\n", status["status"])
			break
		}

		time.Sleep(1 * time.Second)
	}
}

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