> ## Documentation Index
> Fetch the complete documentation index at: https://tbd-6fc993ce-hypeship-browser-pools-docs-refresh.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Create
> Spin up a cloud browser for your agent
Kernel browsers are sandboxed Chromium instances that boot in under 30ms. Your agent creates them on demand, drives them, and tears them down — no infra to provision, no servers to run.
## Your first browser
Install the Kernel SDK first:
* Typescript/Javascript: `npm install @onkernel/sdk`
* Python: `pip install kernel`
* Go: `go get github.com/kernel/kernel-go-sdk`
```typescript Typescript/Javascript theme={null}
import Kernel from '@onkernel/sdk';
const kernel = new Kernel();
const kernelBrowser = await kernel.browsers.create();
console.log(kernelBrowser.session_id);
```
```python Python theme={null}
from kernel import Kernel
kernel = Kernel()
kernel_browser = kernel.browsers.create()
print(kernel_browser.session_id)
```
```go Go theme={null}
package main
import (
"context"
"fmt"
"github.com/kernel/kernel-go-sdk"
)
func main() {
ctx := context.Background()
client := kernel.NewClient()
kernelBrowser, err := client.Browsers.New(ctx, kernel.BrowserNewParams{})
if err != nil {
panic(err)
}
fmt.Println(kernelBrowser.SessionID)
}
```
```bash CLI theme={null}
kernel browsers create
# or with a starting URL and stealth
kernel browsers create --stealth --start-url https://example.com
```
The response includes everything you need to drive the browser: `session_id`, `cdp_ws_url`, `webdriver_ws_url`, and `browser_live_view_url`.
## Pick the right shape
Most of what you'll tune at creation time falls into four buckets:
headful (default) supports live view, replays, and better stealth — ideal for agent workflows on bot-detected sites. headless is lighter (1 gb vs 8 gb), good for simple scraping.
Turn on stealth mode and route through residential, ISP, or datacenter proxies when you're hitting sites with bot detection.
Required for WebGL, video, and canvas-heavy workloads. Trades off standby support.
Persist cookies, storage, and logged-in sessions across runs with a [profile](/auth/profiles), or hand auth off to Kernel entirely with [managed auth](/auth/overview).
## On demand or from a pool
`browsers.create()` boots a browser for you on the spot. That's the right call while you're building, and for workloads that run occasionally.
Once you're running the same task repeatedly — or more than a handful at a time — create a [browser pool](/browsers/pools/quickstart) instead. A pool holds browsers that are already booted with your configuration applied, so `acquire` hands you one that's ready to drive rather than starting one from scratch. Two things get faster: configurations that restart Chromium on creation (custom viewports, extensions, kiosk mode) are already applied, and acquiring from a pool sidesteps the [rate limit](/info/pricing#rate-limiting) on browser creation that you'll otherwise hit at volume.
```typescript Typescript/Javascript theme={null}
// Create the pool once, at deploy time or on startup
await kernel.browserPools.create({ name: 'checkout-pool', size: 20, stealth: true });
// Then, wherever your automation runs
const kernelBrowser = await kernel.browserPools.acquire('checkout-pool', {});
```
```python Python theme={null}
# Create the pool once, at deploy time or on startup
kernel.browser_pools.create(name="checkout-pool", size=20, stealth=True)
# Then, wherever your automation runs
kernel_browser = kernel.browser_pools.acquire("checkout-pool")
```
```go Go theme={null}
// Create the pool once, at deploy time or on startup
if _, err := client.BrowserPools.New(ctx, kernel.BrowserPoolNewParams{
Name: kernel.String("checkout-pool"),
Size: 20,
Stealth: kernel.Bool(true),
}); err != nil {
panic(err)
}
// Then, wherever your automation runs
kernelBrowser, err := client.BrowserPools.Acquire(ctx, "checkout-pool", kernel.BrowserPoolAcquireParams{})
if err != nil {
panic(err)
}
```
```bash CLI theme={null}
kernel browser-pools create checkout-pool --size 20 --stealth
kernel browser-pools acquire checkout-pool
```
An acquired browser returns the same fields as one you created directly, so the rest of your code is identical. Idle browsers in a pool aren't billed — you pay only while a browser is acquired and running — though pool capacity does count against your [concurrency limit](/info/pricing#concurrency-limits).
## Lifecycle
A browser stays alive as long as something is driving it — a CDP or WebDriver client, a [Live View](/browsers/live-view) viewer, or an in-flight [computer controls](/browsers/computer-controls) request. After five seconds with none of those active, it enters [standby](/browsers/standby) — state is preserved, billing stops. Once in standby, after the configurable timeout (60s by default) elapses it's deleted.
We recommend you delete a browser explicitly when you're done with it:
```typescript Typescript/Javascript theme={null}
await kernel.browsers.deleteByID(kernelBrowser.session_id);
```
```python Python theme={null}
kernel.browsers.delete_by_id(kernel_browser.session_id)
```
```go Go theme={null}
if err := client.Browsers.DeleteByID(ctx, kernelBrowser.SessionID); err != nil {
panic(err)
}
```
```bash CLI theme={null}
kernel browsers delete
```
See [Termination & timeouts](/browsers/termination#automatic-deletion-via-timeout) for the full set of teardown options.
## Full example
Putting it together — create a browser, run Playwright code inside it, tear down:
```typescript Typescript/Javascript theme={null}
import Kernel from '@onkernel/sdk';
const kernel = new Kernel();
const kernelBrowser = await kernel.browsers.create();
try {
const response = await kernel.browsers.playwright.execute(
kernelBrowser.session_id,
{
code: `
await page.goto('https://www.onkernel.com');
return await page.title();
`,
},
);
console.log(response.result);
} catch (error) {
console.error(error);
} finally {
await kernel.browsers.deleteByID(kernelBrowser.session_id);
}
```
```python Python theme={null}
from kernel import Kernel
kernel = Kernel()
kernel_browser = kernel.browsers.create()
try:
response = kernel.browsers.playwright.execute(
id=kernel_browser.session_id,
code="""
await page.goto('https://www.onkernel.com')
return await page.title()
""",
)
print(response.result)
except Exception as e:
print(e)
finally:
kernel.browsers.delete_by_id(kernel_browser.session_id)
```
```go Go theme={null}
package main
import (
"context"
"fmt"
"github.com/kernel/kernel-go-sdk"
)
func main() {
ctx := context.Background()
client := kernel.NewClient()
kernelBrowser, err := client.Browsers.New(ctx, kernel.BrowserNewParams{})
if err != nil {
panic(err)
}
defer func() {
if err := client.Browsers.DeleteByID(ctx, kernelBrowser.SessionID); err != nil {
panic(err)
}
}()
response, err := client.Browsers.Playwright.Execute(
ctx,
kernelBrowser.SessionID,
kernel.BrowserPlaywrightExecuteParams{
Code: `
await page.goto('https://www.onkernel.com');
return await page.title();
`,
},
)
if err != nil {
panic(err)
}
fmt.Println(response.Result)
}
```
## What's next
Once you have a browser, you need to drive it. Head to [Control](/introduction/control) to see the four primitives Kernel exposes — computer use, playwright execution, CDP, and WebDriver BiDi — and when to reach for each.
When you're ready to run this in production, the [Browser Pools Quickstart](/browsers/pools/quickstart) shows how to serve your workload from warm, pre-configured browsers instead of creating one per task.