Sandboxes on Northflank cloud

Deploy sandboxes on Northflank's managed infrastructure with isolation enabled by default. CPU sandboxes run in microVMs and GPU sandboxes run under gVisor, with no configuration needed either way. Boot times stay under a second.

This page covers what is specific to Northflank cloud: resource plans, GPU plans, regions, and billing. For the end-to-end walkthrough, start with the quickstart.

Before you start

Isolation on Northflank cloud is automatic. CPU sandboxes run in microVMs, and GPU sandboxes run under gVisor. You do not select a runtime, and there is nothing to configure.

GPU sandboxes have an extra requirement: the project must sit in a GPU-enabled region, such as asia-southeast. You choose a region when you create a project and you cannot move a project afterwards, so pick a GPU-enabled region up front if you plan to run GPU workloads.

Region is fixed at creation

A project's region cannot be changed after the project is created. To move a sandbox to a different region, create a new project in that region and redeploy.

Create a project

Sandboxes run in projects. A project deployed to Northflank's managed cloud gets sandbox isolation automatically.

Click here to create a project.

In the Northflank dashboard, click Create Project.
Enter a project name.
Choose Northflank Cloud as the deployment target.
Select a region. Pick a GPU-enabled one if you plan to run GPU sandboxes, because this cannot be changed later.
Click Create project.

Note the project ID. You pass it as a parameter in every API call that follows.

See create a project for the full walkthrough.

Create a sandbox on Northflank cloud

Projects on Northflank cloud are created from your team dashboard. Any sandbox you deploy into one of those projects runs on Northflank's managed infrastructure automatically, with no extra configuration.

const sandboxId = `sandbox-${crypto.randomUUID().split('-')[4]}`;

await apiClient.create.service.deployment({
  parameters: {
    projectId: 'your-northflank-project-id',
  },
  data: {
    name: sandboxId,
    billing: {
      deploymentPlan: 'nf-compute-200',
    },
    deployment: {
      instances: 1,
      docker: {
        configType: 'customCommand',
        customCommand: 'sleep infinity',
      },
      external: {
        imagePath: 'ubuntu:22.04',
      },
      storage: {
        ephemeralStorage: {
          storageSize: 2048,
        },
      },
    },
  },
});

import uuid

sandbox_id = f"sandbox-{uuid.uuid4().hex[:8]}"

client.create.service.deployment(
    project_id="your-northflank-project-id",
    data={
        "name": sandbox_id,
        "billing": {"deploymentPlan": "nf-compute-200"},
        "deployment": {
            "instances": 1,
            "docker": {
                "configType": "customEntrypointCustomCommand",
                "customEntrypoint": "/bin/bash",
                "customCommand": "-c 'sleep infinity'",
            },
            "external": {"imagePath": "ubuntu:22.04"},
            "storage": {"ephemeralStorage": {"storageSize": 2048}},
        },
    },
)

See create a project if you do not have a project yet.

Resource plans

The billing.deploymentPlan field sets how much CPU and memory a sandbox gets. Northflank cloud offers standard plans from nf-compute-10 at the small end up to nf-compute-2000, with nf-compute-200 a reasonable starting point for most sandboxes.

See the pricing page for the vCPU, memory, and cost of each plan.

You can also list the plans available to your account, with their CPU and memory, using list.plans.

Change a plan at any time by scaling the service. The sandbox restarts with the new allocation, and anything held only in ephemeral storage is lost:

await apiClient.scale.service({
  parameters: {
    projectId: 'your-project-id',
    serviceId: sandboxId,
  },
  data: {
    deploymentPlan: 'nf-compute-400',
  },
});

client.scale.service(
    project_id="your-project-id",
    service_id=sandbox_id,
    data={"deploymentPlan": "nf-compute-400"},
)

On your own cloud you are not limited to these plans. See create custom resource plans.

GPU sandboxes and plans

To run a GPU sandbox, create the project in a GPU-enabled region first, then deploy into it with a GPU deployment plan and a gpu block.

GPU sandboxes run under gVisor rather than the microVMs used for CPU sandboxes. This is applied automatically and is not something you select.

const sandboxId = `gpu-sandbox-${crypto.randomUUID().split('-')[4]}`;

await apiClient.create.service.deployment({
  parameters: {
    projectId: 'your-gpu-project-id', // must be in a GPU-enabled region
  },
  data: {
    name: sandboxId,
    billing: {
      deploymentPlan: 'nf-gpu-a100-80-1g',
    },
    deployment: {
      instances: 1,
      external: {
        imagePath: 'quay.io/jupyter/pytorch-notebook:cuda12-2026-02-09',
      },
      docker: {
        configType: 'default',
      },
      gpu: {
        enabled: true,
        configuration: {
          // Must match the GPU in the deployment plan above.
          gpuType: 'a100-80',
          gpuCount: 1,
          timesliced: false,
        },
      },
      storage: {
        ephemeralStorage: {
          storageSize: 256000,
        },
        // Shared memory. Size generously for your framework's needs.
        shmSize: 174080,
      },
    },
  },
});

import uuid

sandbox_id = f"gpu-sandbox-{uuid.uuid4().hex[:8]}"

client.create.service.deployment(
    project_id="your-gpu-project-id",  # must be in a GPU-enabled region
    data={
        "name": sandbox_id,
        "billing": {"deploymentPlan": "nf-gpu-a100-80-1g"},
        "deployment": {
            "instances": 1,
            "external": {
                "imagePath": "quay.io/jupyter/pytorch-notebook:cuda12-2026-02-09"
            },
            "docker": {"configType": "default"},
            "gpu": {
                "enabled": True,
                "configuration": {
                    # Must match the GPU in the deployment plan above.
                    "gpuType": "a100-80",
                    "gpuCount": 1,
                    "timesliced": False,
                },
            },
            "storage": {
                "ephemeralStorage": {"storageSize": 256000},
                # Shared memory. Size generously for your framework's needs.
                "shmSize": 174080,
            },
        },
    },
)

GPU plans

GPU plans bundle CPU and RAM matched to the GPU model, so you do not size those separately. Plan identifiers follow the pattern nf-gpu-<model>-<memory>-<count>g. Available models include A100 (40GB and 80GB), H100 (80GB), H200, B200, and RTX PRO 6000. For example, nf-gpu-a100-80-1g is a single 80GB A100 and nf-gpu-h100-80-4g is four 80GB H100s.

The gpuType in the gpu block uses the shorter hardware name without the count, such as a100-40, a100-80, h100-80, h200-141, or t4.

Availability varies by region

Not every GPU model is available in every region, and availability changes. Check the plan selector in your dashboard for what you can actually deploy, and contact support@northflank.com about access to a specific GPU or region.

See GPU workloads for driver, image, and optimisation guidance.

Billing

Northflank cloud bills compute per second of runtime. Pausing a sandbox scales it to zero instances, which stops compute charges. Volumes attached to a paused sandbox continue to be billed, because the data is still stored.

Compute is charged per second against the resource plan you selected.
Volumes are charged per GB per month, whether the sandbox is running or paused.
Ephemeral storage is included in the compute charge.

Short-lived sandboxes are cheap to run precisely because of per-second billing: a sandbox that exists for 40 seconds is billed for 40 seconds.

See the pricing page for current rates, and monitor spending to set up billing alerts before costs surprise you.

Next steps

Configure and manage sandboxes

Pause, resume, scale, monitor, and delete your sandboxes.

Sandbox examples

Deep dives into GPUs, volumes, exposed ports, and coding agents.

Add a persistent volume

Add persistent volumes to your deployments.

Sandboxes in your own cloud

Run sandboxes on your own AWS, GCP, Azure, or other cloud infrastructure.