unsandbox.com

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

Request Parameters

Example (Rust)

use reqwest;
use serde_json::json;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let url = "https://api.unsandbox.com/execute";

    let payload = json!({
        "language": "python",
        "code": "print('Hello from unsandbox!')"
    });

    let response = client
        .post(url)
        .header("Content-Type", "application/json")
        .header("Authorization", &format!("Bearer {}", env::var("UNSANDBOX_API_KEY").unwrap_or_else(|_| "unsb-sk-test0-vault-unlck-12345".to_string())))
        .json(&payload)
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;

    if result["success"].as_bool().unwrap_or(false) {
        println!("Output: {}", result["stdout"].as_str().unwrap_or(""));
    } else {
        println!("Error: {}", result["error"].as_str().unwrap_or(""));
    }

    Ok(())
}

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

use reqwest;
use serde_json::json;
use std::env;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    // Submit job
    let url = "https://api.unsandbox.com/execute/async";
    let payload = json!({
        "language": "rust",
        "code": "fn main() { println!(\"Computing...\"); }",
        "ttl": 300
    });

    let response = client
        .post(url)
        .header("Content-Type", "application/json")
        .header("Authorization", &format!("Bearer {}", env::var("UNSANDBOX_API_KEY").unwrap_or_else(|_| "unsb-sk-test0-vault-unlck-12345".to_string())))
        .json(&payload)
        .send()
        .await?;

    let job: serde_json::Value = response.json().await?;
    let job_id = job["job_id"].as_str().unwrap();

    println!("Job submitted: {}", job_id);

    // Poll for results
    let status_url = format!("https://api.unsandbox.com/jobs/{}", job_id);
    loop {
        let status_response = client
            .get(&status_url)
            .header("Authorization", &format!("Bearer {}", env::var("UNSANDBOX_API_KEY").unwrap_or_else(|_| "unsb-sk-test0-vault-unlck-12345".to_string())))
            .send()
            .await?;

        let status: serde_json::Value = status_response.json().await?;

        match status["status"].as_str().unwrap() {
            "completed" => {
                let result = &status["result"];
                if result["success"].as_bool().unwrap_or(false) {
                    println!("Output: {}", result["stdout"].as_str().unwrap_or(""));
                } else {
                    println!("Error: {}", result["stderr"].as_str().unwrap_or(""));
                }
                break;
            }
            "timeout" | "cancelled" => {
                println!("Job {}", status["status"].as_str().unwrap());
                break;
            }
            _ => {}
        }

        sleep(Duration::from_secs(1)).await; // Wait 1 second before polling again
    }

    Ok(())
}

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

use reqwest;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let job_id = "job_1234567890_abc";
    let url = format!("https://api.unsandbox.com/jobs/{}", job_id);

    let response = client
        .get(&url)
        .header("Authorization", &format!("Bearer {}", env::var("UNSANDBOX_API_KEY").unwrap_or_else(|_| "unsb-sk-test0-vault-unlck-12345".to_string())))
        .send()
        .await?;

    let job: serde_json::Value = response.json().await?;

    println!("Status: {}", job["status"].as_str().unwrap());
    if job["status"] == "completed" {
        let result = &job["result"];
        println!("Success: {}", result["success"].as_bool().unwrap());
        println!("Output: {}", result["stdout"].as_str().unwrap_or(""));
    }

    Ok(())
}

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

use reqwest;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let url = "https://api.unsandbox.com/jobs";

    let response = client
        .get(url)
        .header("Authorization", &format!("Bearer {}", env::var("UNSANDBOX_API_KEY").unwrap_or_else(|_| "unsb-sk-test0-vault-unlck-12345".to_string())))
        .send()
        .await?;

    let jobs: Vec<serde_json::Value> = response.json().await?;

    for job in jobs {
        println!(
            "{}: {} ({})",
            job["job_id"].as_str().unwrap(),
            job["status"].as_str().unwrap(),
            job["language"].as_str().unwrap()
        );
    }

    Ok(())
}

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

use reqwest;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let job_id = "job_1234567890_abc";
    let url = format!("https://api.unsandbox.com/jobs/{}", job_id);

    let response = client
        .delete(&url)
        .header("Authorization", &format!("Bearer {}", env::var("UNSANDBOX_API_KEY").unwrap_or_else(|_| "unsb-sk-test0-vault-unlck-12345".to_string())))
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;

    println!("Cancelled: {}", result["message"].as_str().unwrap());
    if let Some(partial_result) = result.get("result") {
        println!("Partial output: {}", partial_result["stdout"].as_str().unwrap_or(""));
    }

    Ok(())
}

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

use reqwest;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let url = "https://api.unsandbox.com/run";

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

    let response = client
        .post(url)
        .header("Content-Type", "text/plain")
        .header("Authorization", &format!("Bearer {}", env::var("UNSANDBOX_API_KEY").unwrap_or_else(|_| "unsb-sk-test0-vault-unlck-12345".to_string())))
        .body(code)
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;

    println!("Detected: {}", result["detected_language"].as_str().unwrap());
    println!("Output: {}", result["stdout"].as_str().unwrap());

    Ok(())
}

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

use reqwest;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let url = "https://api.unsandbox.com/run/async";

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

    // Submit job
    let response = client
        .post(url)
        .header("Content-Type", "text/plain")
        .header("Authorization", &format!("Bearer {}", env::var("UNSANDBOX_API_KEY").unwrap_or_else(|_| "unsb-sk-test0-vault-unlck-12345".to_string())))
        .body(code)
        .send()
        .await?;

    let job: serde_json::Value = response.json().await?;
    let job_id = job["job_id"].as_str().unwrap();

    println!("Job submitted: {}", job_id);

    // Poll for results
    let status_url = format!("https://api.unsandbox.com/jobs/{}", job_id);
    loop {
        let status_response = client
            .get(&status_url)
            .header("Authorization", &format!("Bearer {}", env::var("UNSANDBOX_API_KEY").unwrap_or_else(|_| "unsb-sk-test0-vault-unlck-12345".to_string())))
            .send()
            .await?;

        let status: serde_json::Value = status_response.json().await?;

        match status["status"].as_str().unwrap() {
            "completed" => {
                let result = &status["result"];
                println!("Detected: {}", result["detected_language"].as_str().unwrap());
                if result["success"].as_bool().unwrap_or(false) {
                    println!("Output: {}", result["stdout"].as_str().unwrap_or(""));
                }
                break;
            }
            "timeout" | "cancelled" => {
                println!("Job {}", status["status"].as_str().unwrap());
                break;
            }
            _ => {}
        }

        sleep(Duration::from_secs(1)).await;
    }

    Ok(())
}

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