unsandbox.com

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

Request Parameters

Example (Perl)

#!/usr/bin/env perl
use strict;
use warnings;
use HTTP::Tiny;
use JSON::PP qw(encode_json decode_json);

my $http = HTTP::Tiny->new();

my $payload = encode_json({
    language => 'perl',
    code => 'print "Hello from unsandbox!\n";'
});

my $api_key = $ENV{UNSANDBOX_API_KEY} // "unsb-sk-test0-vault-unlck-12345";
my $response = $http->request('POST', 'https://api.unsandbox.com/execute', {
    headers => {
        'Content-Type' => 'application/json',
        'Authorization' => "Bearer $api_key"
    },
    content => $payload
});

die "Request failed: $response->{status} $response->{reason}\n" unless $response->{success};

my $result = decode_json($response->{content});
print $result->{stdout};

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

#!/usr/bin/env perl
use strict;
use warnings;
use HTTP::Tiny;
use JSON::PP qw(encode_json decode_json);

my $http = HTTP::Tiny->new();
my $api_key = $ENV{UNSANDBOX_API_KEY} // "unsb-sk-test0-vault-unlck-12345";

# Submit job
my $payload = encode_json({
    language => 'perl',
    code => 'print "Computing...\n";',
    ttl => 300
});

my $response = $http->request('POST', 'https://api.unsandbox.com/execute/async', {
    headers => {
        'Content-Type' => 'application/json',
        'Authorization' => "Bearer $api_key"
    },
    content => $payload
});

die "Request failed: $response->{status} $response->{reason}\n" unless $response->{success};

my $result = decode_json($response->{content});
my $job_id = $result->{job_id};
print "Job submitted: $job_id\n";

# Poll for results
while (1) {
    my $status_response = $http->get("https://api.unsandbox.com/jobs/$job_id", {
        headers => {
            'Authorization' => "Bearer $api_key"
        }
    });

    if ($status_response->{success}) {
        my $status = decode_json($status_response->{content});
        my $state = $status->{status};

        if ($state eq 'completed') {
            print $status->{stdout};
            last;
        } elsif ($state eq 'timeout' || $state eq 'cancelled') {
            print "Job $state\n";
            last;
        }
    }

    sleep 1;
}

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

#!/usr/bin/env perl
use strict;
use warnings;
use HTTP::Tiny;
use JSON::PP qw(decode_json encode_json);

my $http = HTTP::Tiny->new();
my $api_key = $ENV{UNSANDBOX_API_KEY} // "unsb-sk-test0-vault-unlck-12345";

my $response = $http->get('https://api.unsandbox.com/jobs/job_1234567890_abc', {
    headers => {
        'Authorization' => "Bearer $api_key"
    }
});

if ($response->{success}) {
    my $result = decode_json($response->{content});
    print encode_json($result);
    print "\n";
} elsif ($response->{status} == 404) {
    print "Job not found (already completed or never existed)\n";
} else {
    die "Request failed: $response->{status} $response->{reason}\n";
}

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

#!/usr/bin/env perl
use strict;
use warnings;
use HTTP::Tiny;
use JSON::PP qw(encode_json decode_json);

my $http = HTTP::Tiny->new();
my $api_key = $ENV{UNSANDBOX_API_KEY} // "unsb-sk-test0-vault-unlck-12345";

my $response = $http->get('https://api.unsandbox.com/jobs', {
    headers => {
        'Authorization' => "Bearer $api_key"
    }
});

die "Request failed: $response->{status} $response->{reason}\n" unless $response->{success};

my $result = decode_json($response->{content});
print encode_json($result);
print "\n";

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

#!/usr/bin/env perl
use strict;
use warnings;
use HTTP::Tiny;
use JSON::PP qw(decode_json encode_json);

my $http = HTTP::Tiny->new();
my $api_key = $ENV{UNSANDBOX_API_KEY} // "unsb-sk-test0-vault-unlck-12345";

my $response = $http->delete('https://api.unsandbox.com/jobs/job_1234567890_abc', {
    headers => {
        'Authorization' => "Bearer $api_key"
    }
});

if ($response->{success}) {
    my $result = decode_json($response->{content});
    print encode_json($result);
    print "\n";
} elsif ($response->{status} == 404) {
    print "Job not found (already completed or never existed)\n";
} else {
    die "Request failed: $response->{status} $response->{reason}\n";
}

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

#!/usr/bin/env perl
use strict;
use warnings;
use HTTP::Tiny;
use JSON::PP qw(decode_json);

my $http = HTTP::Tiny->new();
my $api_key = $ENV{UNSANDBOX_API_KEY} // "unsb-sk-test0-vault-unlck-12345";

my $code = qq{#!/usr/bin/env perl
print "Language auto-detected!\\n";};

my $response = $http->request('POST', 'https://api.unsandbox.com/run', {
    headers => {
        'Content-Type' => 'text/plain',
        'Authorization' => "Bearer $api_key"
    },
    content => $code
});

die "Request failed: $response->{status} $response->{reason}\n" unless $response->{success};

my $result = decode_json($response->{content});
print $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 (Perl)

#!/usr/bin/env perl
use strict;
use warnings;
use HTTP::Tiny;
use JSON::PP qw(encode_json decode_json);

my $http = HTTP::Tiny->new();
my $api_key = $ENV{UNSANDBOX_API_KEY} // "unsb-sk-test0-vault-unlck-12345";

# Submit job
my $code = qq{#!/usr/bin/env perl
print "Running async with auto-detect!\\n";};

my $response = $http->request('POST', 'https://api.unsandbox.com/run/async', {
    headers => {
        'Content-Type' => 'text/plain',
        'Authorization' => "Bearer $api_key"
    },
    content => $code
});

die "Request failed: $response->{status} $response->{reason}\n" unless $response->{success};

my $result = decode_json($response->{content});
my $job_id = $result->{job_id};
print "Job submitted: $job_id\n";

# Poll for results
while (1) {
    my $status_response = $http->get("https://api.unsandbox.com/jobs/$job_id", {
        headers => {
            'Authorization' => "Bearer $api_key"
        }
    });

    if ($status_response->{success}) {
        my $status = decode_json($status_response->{content});
        my $state = $status->{status};

        if ($state eq 'completed') {
            print encode_json($status);
            print "\n";
            last;
        } elsif ($state eq 'timeout' || $state eq 'cancelled') {
            print "Job $state\n";
            last;
        }
    }

    sleep 1;
}

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