> ## Documentation Index
> Fetch the complete documentation index at: https://kernel.sh/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Regional Browsers

> Choose where your browsers run to reduce automation and live view latency

Regional browsers let you run browsers closer to your automation code and the people using [live view](https://kernel.sh/docs/browsers/live-view.md). Choose a region when you create a browser or a [browser pool](https://kernel.sh/docs/browsers/pools.md) to reduce network round trips during browser interactions.

## Available regions

Choose from `us-east`, `eu-west`, and `ap-southeast`.

Region selection is available on [Start-Up and Enterprise plans](https://kernel.sh/docs/info/pricing.md), at the same usage rates as default browsers. If you omit `region` when creating a browser or pool, it defaults to `us-east`.

> [!NOTE]
>
> Regional browsers support CPU browsers, browser pools, and Managed Auth. Regional support for GPU browsers, Apps, and Invocations is coming soon.

## Create a regional browser

Set `region` when creating a browser. You can run browsers in multiple regions within the same project; there's no account-wide region setting.

```typescript Typescript/Javascript theme={null}
import Kernel from '@onkernel/sdk';

const kernel = new Kernel();

const browser = await kernel.browsers.create({
  region: "eu-west"
});

console.log(browser.cdp_ws_url);
```

```python Python theme={null}
from kernel import Kernel

kernel = Kernel()

browser = kernel.browsers.create(
    region="eu-west"
)

print(browser.cdp_ws_url)
```

```go Go theme={null}
package main

import (
	"context"
	"fmt"

	"github.com/kernel/kernel-go-sdk"
)

func main() {
	ctx := context.Background()
	client := kernel.NewClient()

	browser, err := client.Browsers.New(ctx, kernel.BrowserNewParams{
		Region: kernel.BrowserNewParamsRegionEuWest,
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(browser.CdpWsURL)
}
```

Connect using the returned `cdp_ws_url` as usual. Your existing Playwright or CDP code doesn't need to change, and the browser's live view connects to the selected region.

You can also choose **Region** in the browser configuration dialog in the [dashboard](https://dashboard.onkernel.com) before launching a browser.

A browser's region is fixed when you create it. To use a different region, create a new browser.

## Run Managed Auth in a region

A Managed Auth connection stores a default browser region for its initial login, health checks, and automatic reauthentication. In the dashboard, choose **Region** under **Advanced options** when you create a connection, or under **Browser defaults** when you edit one.

With the CLI, pass `--region` when you create or update a connection:

```bash theme={null}
kernel auth connections create \
  --domain example.com \
  --profile-name my-profile \
  --region eu-west

kernel auth connections update conn_01k3m8v2c9w4n7q6 \
  --region ap-southeast
```

For one login in a different region, pass `--region` to `kernel auth connections login`. The override applies only to that login.

The MCP server exposes the same behavior through `browser_region` on `manage_auth_connections`:

```json theme={null}
{
  "action": "create",
  "domain": "example.com",
  "profile_name": "my-profile",
  "browser_region": "eu-west"
}
```

For the secure login panel, pass `region` to `open_auth_login`. See [Connection Configuration](https://kernel.sh/docs/auth/configuration.md#browser-region) for SDK examples and update semantics.

## Create a regional browser pool

Set `region` when creating a pool, or choose **Region** in the dashboard's pool creation dialog:

```typescript Typescript/Javascript theme={null}
const pool = await kernel.browserPools.create({
  name: "checkout-sg",
  size: 5,
  region: "ap-southeast"
});
```

```python Python theme={null}
pool = kernel.browser_pools.create(
    name="checkout-sg",
    size=5,
    region="ap-southeast"
)
```

```go Go theme={null}
pool, err := client.BrowserPools.New(ctx, kernel.BrowserPoolNewParams{
	Name:   kernel.String("checkout-sg"),
	Size:   5,
	Region: kernel.BrowserPoolNewParamsRegionApSoutheast,
})
if err != nil {
	panic(err)
}

fmt.Println(pool.ID)
```

Every browser you [acquire](https://kernel.sh/docs/browsers/pools.md#acquire-a-browser) runs in the pool's region. You don't specify a region when acquiring or releasing browsers. The pool's region is fixed at creation.

## List browsers by region

Pass `region` to filter a browser list:

```typescript Typescript/Javascript theme={null}
const browsers = await kernel.browsers.list({ region: "eu-west" });
```

```python Python theme={null}
browsers = kernel.browsers.list(region="eu-west")
```

```go Go theme={null}
browsers, err := client.Browsers.List(ctx, kernel.BrowserListParams{
	Region: kernel.BrowserListParamsRegionEuWest,
})
if err != nil {
	panic(err)
}

fmt.Println(browsers.Items)
```

Browser pool lists support the same filter. Omit it to list resources across all regions. The returned browser and pool objects include their `region`; requests to get or delete a resource by ID don't need a region parameter.

## What stays global

* **Profiles and extensions** aren't tied to a region. You can reuse your existing [profiles](https://kernel.sh/docs/browsers/profiles.md) and [extensions](https://kernel.sh/docs/browsers/extensions) with browsers in any region within the same project.
* **Proxy configurations** can be reused across regions. Browser region chooses where the browser runs; [proxy location](https://kernel.sh/docs/proxies/overview.md) controls the exit IP websites see.
* **Concurrency and rate limits** apply across all regions combined, not separately in each region. Browser pool capacity counts toward the same [concurrency limit](https://kernel.sh/docs/browsers/concurrency-and-limits.md#concurrency).

> [!WARNING]
>
> Regional browsers reduce interaction latency; they don't provide a data residency guarantee. Profiles, replays, and session metadata aren't confined to the browser's selected region and may be stored or processed in the US.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.