Cloud Workspaces

Dedicated Code Execution Runtimes

Deploy secure, isolated container sandboxes for code execution. Provision dedicated cloud workspaces, install custom dependencies, control container lifecycles, and monitor system resources in real time — all through a single API.

Create Workspace Manage Containers

Watch a Container Come to Life

A real container lifecycle — from provisioning to code execution — in your browser.

main.py

# Waiting for container...

terminal

Live Resource Monitor

Real-time system metrics for every running container — CPU, memory, disk, and network.

Container my-sandbox — Running

CPU Usage 0%

4 vCPU cores allocated

RAM Usage 0 GB

16 GB total allocated

Disk I/O 0 MB/s

SSD-backed persistent volume

Network 0 Mbps

1 Gbps burst bandwidth

How It Works

Three simple steps from provisioning to production-ready code execution.

Provision Runtime

Spin up a dedicated container in seconds. Choose your base image, allocate resources, and configure networking through the API or dashboard.

Install Dependencies

Declare packages in your workspace config or install them dynamically at runtime. All changes persist across container restarts.

Execute & Monitor

Run code securely inside your isolated sandbox. Stream stdout/stderr in real time and monitor CPU, memory, and I/O metrics live.

Platform Capabilities

Everything you need for secure, scalable cloud code execution.

Isolated VM Sandboxes

Every workspace runs in a fully isolated container with its own filesystem, process tree, and network namespace — zero cross-contamination between environments.

Dynamic Package Sync

Add libraries to your workspace config and our sync engine installs, validates, and deploys dependency changes automatically — no manual rebuilds needed.

Live Metrics Monitoring

Track CPU load, memory allocation, disk I/O, and network throughput in real time. Set threshold alerts and export metrics via our REST API.

Container Lifecycle Control

Start, pause, restart, and terminate containers programmatically. Fine-grained lifecycle management through both the dashboard and the SDK.

Auto-Scaling Resources

Containers dynamically scale CPU and memory allocation based on workload demand. Burst into extra capacity during heavy computation, scale down at idle.

Persistent Storage

Files, databases, and artifacts persist across container sessions. Mount SSD-backed volumes that survive restarts, so your work is never lost.

Quickstart Integration

Get up and running in minutes with our SDK, REST API, or WebSocket streams.

# Install: pip install requests
import requests

# Step 1: Create a new secure sandbox runtime
response = requests.post(
    "https://embedenv.com/api/v1/sandbox/create/",
    headers={"Authorization": "Bearer YOUR_API_KEY"}
)
sandbox = response.json()
sandbox_id = sandbox["sandbox_id"]
print(f"Sandbox {sandbox_id} is ready!")

# Step 2: Execute code inside the sandbox runtime
result = requests.post(
    "https://embedenv.com/api/v1/sandbox/execute/",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "sandbox_id": sandbox_id,
        "code": "import numpy as np; print(np.mean(np.random.randn(1000)))",
        "language": "python"
    }
)
print(result.json()["stdout"])

# Create a secure sandbox runtime container
curl -X POST https://embedenv.com/api/v1/sandbox/create/ \
  -H "Authorization: Bearer YOUR_API_KEY"

# Execute code inside the sandbox container
curl -X POST https://embedenv.com/api/v1/sandbox/execute/ \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "sandbox_id": "YOUR_SANDBOX_ID",
    "code": "import numpy as np\ndata = np.random.randn(1000)\nprint(f\"Mean: {np.mean(data):.4f}\")",
    "language": "python"
  }'

// Connect to a workspace container via live WebSocket
const ws = new WebSocket(
  "wss://embedenv.com/ws/spaces/WORKSPACE_ID/"
);

ws.onopen = () => {
  console.log("Connected to workspace space bridge stream");

  // Send interactive command/execution payload
  ws.send(JSON.stringify({
    "type": "init",
    "public_key": "YOUR_API_KEY",
    "secret_key": "YOUR_SECRET_KEY"
  }));
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  if (data.type === "stdout") {
    console.log("[OUTPUT]", data.content);
  } else if (data.type === "metrics") {
    console.log("[CPU]", data.cpu, "[RAM]", data.ram);
  } else if (data.type === "complete") {
    console.log("Execution finished in", data.duration, "ms");
  }
};

ws.onerror = (err) => console.error("Stream error:", err);
ws.onclose = () => console.log("Stream closed");

RAM per Container

Cold Start

Uptime SLA

Packages Pre-installed