# Regions (/docs/regions)

Every Daytona sandbox runs in a **region**: a geographic or logical grouping of compute infrastructure. When creating a sandbox, you can target a specific region, and Daytona schedules the workload on available capacity within that region.

## Shared regions [#shared-regions]

Regions managed by Daytona and available to all organizations:

| **Region**    | **Target** |
| ------------- | ---------- |
| United States | **`us`**   |
| Europe        | **`eu`**   |

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

```python
from daytona import Daytona, DaytonaConfig

# Configure Daytona to use the US region
config = DaytonaConfig(
    target="us"
)

# Initialize the Daytona client with the specified configuration
daytona = Daytona(config)

# Create a sandbox in the US region
sandbox = daytona.create()
```

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

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

// Configure Daytona to use the US region
const daytona = new Daytona({
  target: 'us',
})

// Create a sandbox in the US region
const sandbox = await daytona.create()
```

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

```ruby
require 'daytona'

# Configure Daytona to use the US region
config = Daytona::Config.new(
  target: 'us'
)

# Initialize the Daytona client with the specified configuration
daytona = Daytona::Daytona.new(config)

# Create a sandbox in the US region
sandbox = daytona.create
```

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

```go
package main

import (
	"context"

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

func main() {
	// Configure Daytona to use the US region
	client, _ := daytona.NewClientWithConfig(&types.DaytonaConfig{
		Target: "us",
	})

	// Create a sandbox in the US region
	ctx := context.Background()
	_, _ = client.Create(ctx, nil)
}
```

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

```java
import io.daytona.sdk.Daytona;
import io.daytona.sdk.DaytonaConfig;
import io.daytona.sdk.Sandbox;

public class App {
    public static void main(String[] args) {
        // Configure Daytona to use the US region
        DaytonaConfig config = new DaytonaConfig.Builder()
                .apiKey(System.getenv("DAYTONA_API_KEY"))
                .target("us")
                .build();

        try (Daytona daytona = new Daytona(config)) {
            // Create a sandbox in the US region
            Sandbox sandbox = daytona.create();
        }
    }
}
```

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

```bash
# Create a sandbox in the US region
curl 'https://app.daytona.io/api/sandbox' \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --data '{
  "target": "us"
}'
```

</TabItem>
</Tabs>

List regions managed by Daytona and available to all organizations:

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

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

</TabItem>
</Tabs>

## Earth region [#earth-region]

[GPU sandboxes](/docs/sandboxes#gpu-sandboxes) and [GPU snapshots](/docs/snapshots#gpu-snapshots) on shared regions belong to the **Earth** region: a global region that spans the shared GPU fleet. Daytona selects the shared region a GPU workload runs in and ignores the region preference.

Earth is not a physical region. It is not returned by the regions or shared regions endpoints, and it is a reserved region ID that cannot be assigned to a [custom region](#custom-regions). GPU sandboxes and snapshots on [dedicated](#dedicated-regions) and [custom](#custom-regions) regions keep their real region ID and remain targetable.

The earth region ID appears in:

- **`target`** of a GPU sandbox on a shared region
- **`regionIds`** of a GPU snapshot on a shared region
- **`regionUsage`** entries of the [usage overview](/docs/organizations#usage-overview): one **`earth`** entry per sandbox class aggregates the shared GPU quota and usage; shared region entries report no GPU quota
- [Available sandbox classes](/docs/organizations#list-available-sandbox-classes): one **`earth`** entry per sandbox class with **`gpuAvailable`** and **`allowedGpuTypes`**; shared region entries report **`gpuAvailable: false`**
- **Region quota of a GPU sandbox**: GPU quota fields aggregated under **`earth`**
- **`region.id`** attribute of the GPU [organization metrics](/docs/observability/otel-collection#organization-metrics)
- **Error messages** that reference the region of a GPU workload

## Dedicated regions [#dedicated-regions]

Dedicated regions are managed by Daytona and provisioned exclusively for an organization. The infrastructure is not shared with other organizations, and Daytona operates it as a managed service.

<Callout type="note">
Contact [sales@daytona.io](mailto:sales@daytona.io) to set up a dedicated region for your organization.
</Callout>

## Custom regions [#custom-regions]

Custom regions run on compute that your organization provides and manages. Attach your own machines through [bring your own compute (BYOC)](/docs/bring-your-own-compute) to control data locality, compliance, and infrastructure configuration, and scale capacity independently within each region.

Custom regions have no limits on concurrent resource usage: capacity is bounded only by the compute you attach.