# 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](/docs/v1/application/sandboxes/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.

> [!warning] 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.

> [!note]
>
> [Click here](https://app.northflank.com/s/account/projects/new) to create a project.

1. In the Northflank dashboard, click Create Project.

2. Enter a project name.

3. Choose Northflank Cloud as the deployment target.

4. Select a [region](/docs/v1/application/run/deploy-to-a-region). Pick a GPU-enabled one if you plan to run GPU sandboxes, because this cannot be changed later.

5. Click Create project.

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

See [create a project](/docs/v1/application/getting-started/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.

JavaScriptPython
```javascript
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,
        },
      },
    },
  },
});
```

```python
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](/docs/v1/application/getting-started/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](https://northflank.com/pricing) 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:

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

```python
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](/docs/v1/application/bring-your-own-cloud/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.

JavaScriptPython
```javascript
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,
      },
    },
  },
});
```

```python
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`.

> [!note] 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](mailto:support@northflank.com)](mailto:support@northflank.com) about access to a specific GPU or region.

See [GPU workloads](/docs/v1/application/gpu-workloads/gpus-on-northflank) 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](https://northflank.com/pricing) for current rates, and [monitor spending](/docs/v1/application/billing/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.](/v1/application/sandboxes/configure-and-manage-sandboxes)
- [Sandbox examples: Deep dives into GPUs, volumes, exposed ports, and coding agents.](/v1/application/sandboxes/examples)
- [Add a persistent volume: Add persistent volumes to your deployments.](/v1/application/databases-and-persistence/add-a-volume)
- [Sandboxes in your own cloud: Run sandboxes on your own AWS, GCP, Azure, or other cloud infrastructure.](/v1/application/sandboxes/sandboxes-in-your-own-cloud)