---
title: Warm Pools
description: Pre-created, running sandboxes built from a snapshot.
---


Warm pools keep a configured number of pre-created, running sandboxes built from a [snapshot](/docs/en/snapshots) in a specific [region](/docs/en/regions). When you create a sandbox that matches a pool, Daytona hands over a warm sandbox instead of provisioning a new one, so the sandbox is available instantly.

A sandbox create request claims a warm sandbox when all of the following match the pool:

- The same snapshot
- The same target region
- The snapshot's default resources (CPU, memory, and disk)
- The default OS user (`daytona`)
- No custom environment variables, volumes, or secrets

When a request claims a warm sandbox, Daytona applies the name, labels, auto-stop, auto-pause, auto-archive, and auto-delete intervals, and network settings from the create request, and creates a new warm sandbox in the background to keep the pool at its configured size.

An organization can have one warm pool per snapshot per region. Warm sandboxes count against your organization quota, so the pool size multiplied by the snapshot's resources must fit within your region quota.

<Callout type="note">
Warm pools must be enabled for your organization. Contact [support@daytona.io](mailto:support@daytona.io).
</Callout>

## Create a warm pool

Create a warm pool for a snapshot.

The snapshot must be active and available in the target region. Creating a second pool for the same snapshot and region returns a `409` error.

| **Parameter**  | **Required** | **Description**                                                                       |
| -------------- | ------------ | ------------------------------------------------------------------------------------- |
| **`snapshot`** | Yes          | Snapshot ID or name to keep warm sandboxes for                                         |
| **`pool`**     | Yes          | Number of warm sandboxes to keep ready; minimum **`1`**, capped by the organization quota |
| **`target`**   | No           | Target region for the warm pool; defaults to the organization default region          |

1. Go to [Daytona Snapshots ↗](https://app.daytona.io/dashboard/snapshots)
2. Click the snapshot you want to create a warm pool for
3. In the **Warm Pool** section, select a region and enter the **Pool size**
4. Click <Button>Add warm pool</Button>

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```python
from daytona import Daytona

daytona = Daytona()
pool = daytona.warm_pool.create("my-snapshot", pool=3, target="us")
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```typescript
import { Daytona } from '@daytona/sdk'

const daytona = new Daytona()
const pool = await daytona.warmPool.create({
  snapshot: 'my-snapshot',
  pool: 3,
  target: 'us',
})
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```ruby
require 'daytona'

daytona = Daytona::Daytona.new
pool = daytona.warm_pool.create('my-snapshot', 3, target: 'us')
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```go
package main

import (
	"context"
	"log"

	"github.com/daytona/clients/sdk-go/pkg/daytona"
	"github.com/daytona/clients/sdk-go/pkg/types"
)

func main() {
	client, err := daytona.NewClient()
	if err != nil {
		log.Fatal(err)
	}

	target := "us"
	pool, err := client.WarmPool.Create(context.Background(), &types.CreateWarmPoolParams{
		Snapshot: "my-snapshot",
		Pool:     3,
		Target:   &target,
	})
	if err != nil {
		log.Fatal(err)
	}
	_ = pool
}
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```java
import io.daytona.sdk.Daytona;
import io.daytona.sdk.model.WarmPool;

public class App {
    public static void main(String[] args) {
        try (Daytona daytona = new Daytona()) {
            WarmPool pool = daytona.warmPool().create("my-snapshot", 3, "us");
        }
    }
}
```

</TabItem>
<TabItem label="API" icon="seti:json">

```bash
curl 'https://app.daytona.io/api/warm-pools' \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --data '{
  "snapshot": "my-snapshot",
  "pool": 3,
  "target": "us"
}'
```

</TabItem>
</Tabs>

## List warm pools

List the warm pools in your organization. Each pool reports the desired size (`pool`) and the number of warm sandboxes currently ready (`currentSize`). If Daytona cannot fill the pool, for example because the snapshot is no longer active, the `errorReason` field explains why.

1. Go to [Daytona Snapshots ↗](https://app.daytona.io/dashboard/snapshots)
2. Click a snapshot to see its warm pools per region in the **Warm Pool** section

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```python
for pool in daytona.warm_pool.list():
    print(f"{pool.snapshot}: {pool.current_size}/{pool.pool} ready")
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```typescript
const pools = await daytona.warmPool.list()
for (const pool of pools) {
  console.log(`${pool.snapshot}: ${pool.currentSize}/${pool.pool} ready`)
}
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```ruby
daytona.warm_pool.list.each do |pool|
  puts "#{pool.snapshot}: #{pool.current_size}/#{pool.pool} ready"
end
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```go
pools, err := client.WarmPool.List(ctx)
if err != nil {
	log.Fatal(err)
}
for _, pool := range pools {
	fmt.Printf("%s: %d/%d ready\n", pool.Snapshot, pool.CurrentSize, pool.Pool)
}
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```java
for (WarmPool pool : daytona.warmPool().list()) {
    System.out.println(pool.getSnapshot() + ": "
        + pool.getCurrentSize() + "/" + pool.getPool() + " ready");
}
```

</TabItem>
<TabItem label="API" icon="seti:json">

```bash
curl 'https://app.daytona.io/api/warm-pools' \
  --header 'Authorization: Bearer YOUR_API_KEY'
```

</TabItem>
</Tabs>

## Resize a warm pool

Resize a warm pool to change the desired number of warm sandboxes. Daytona converges the pool to the new size in the background: it creates warm sandboxes when the pool is below the target and destroys the newest unclaimed ones when it is above. Setting `pool` to `0` drains the pool without deleting its configuration.

1. Go to [Daytona Snapshots ↗](https://app.daytona.io/dashboard/snapshots)
2. Click the snapshot to resize the warm pool for
3. In the **Warm Pool** section, click <Button>Edit</Button>
4. Enter the new **Pool size** and click <Button>Save</Button>

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```python
daytona.warm_pool.update(pool.id, pool=5)
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```typescript
await daytona.warmPool.update(pool.id, { pool: 5 })
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```ruby
daytona.warm_pool.update(pool.id, 5)
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```go
updated, err := client.WarmPool.Update(ctx, pool.ID, 5)
if err != nil {
	log.Fatal(err)
}
_ = updated
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```java
daytona.warmPool().update(pool.getId(), 5);
```

</TabItem>
<TabItem label="API" icon="seti:json">

```bash
curl 'https://app.daytona.io/api/warm-pools/{warmPoolId}' \
  --request PATCH \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --data '{
  "pool": 5
}'
```

</TabItem>
</Tabs>

## Delete a warm pool

Delete a warm pool and destroy all of its unclaimed warm sandboxes. Sandboxes already claimed from the pool are not affected. Deleting a snapshot also deletes its warm pools.

1. Go to [Daytona Snapshots ↗](https://app.daytona.io/dashboard/snapshots)
2. Click the snapshot to delete the warm pool for
3. In the **Warm Pool** section, click the trash icon
4. Click <Button>Delete</Button> to confirm

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```python
daytona.warm_pool.delete(pool.id)
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```typescript
await daytona.warmPool.delete(pool.id)
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```ruby
daytona.warm_pool.delete(pool.id)
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```go
err := client.WarmPool.Delete(ctx, pool.ID)
if err != nil {
	log.Fatal(err)
}
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```java
daytona.warmPool().delete(pool.getId());
```

</TabItem>
<TabItem label="API" icon="seti:json">

```bash
curl 'https://app.daytona.io/api/warm-pools/{warmPoolId}' \
  --request DELETE \
  --header 'Authorization: Bearer YOUR_API_KEY'
```

</TabItem>
</Tabs>

## List warm sandboxes

Unclaimed warm sandboxes are excluded from sandbox listings by default. Set the `includeWarm` query parameter to include them. While a sandbox waits in a pool, its `warmPoolId` field holds the id of the pool; the field is cleared when the sandbox is claimed.

1. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes)
2. Enable the **Warm pool** filter; warm sandboxes show a **Warm** badge next to their name

<Tabs syncKey="language">
<TabItem label="API" icon="seti:json">

```bash
curl 'https://app.daytona.io/api/sandbox?includeWarm=true' \
  --header 'Authorization: Bearer YOUR_API_KEY'
```

</TabItem>
</Tabs>