Create

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

import Kernel from '@onkernel/sdk';

const kernel = new Kernel();

const kernelBrowser = await kernel.browsers.create();
console.log(kernelBrowser.session_id);

from kernel import Kernel

kernel = Kernel()

kernel_browser = kernel.browsers.create()
print(kernel_browser.session_id)

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)
}

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:

Headless vs headful

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.

Stealth and proxies

Turn on stealth mode and route through residential, ISP, or datacenter proxies when you’re hitting sites with bot detection.

GPU acceleration

Required for WebGL, video, and canvas-heavy workloads. Trades off standby support.

Profiles and auth

Persist cookies, storage, and logged-in sessions across runs with a profile, or hand auth off to Kernel entirely with managed auth.

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 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 on browser creation that you’ll otherwise hit at volume.

// 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', {});

# 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")

// 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)
}

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.

Lifecycle

A browser stays alive as long as something is driving it — a CDP or WebDriver client, a Live View viewer, or an in-flight computer controls request. After five seconds with none of those active, it enters 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:

await kernel.browsers.deleteByID(kernelBrowser.session_id);

kernel.browsers.delete_by_id(kernel_browser.session_id)

if err := client.Browsers.DeleteByID(ctx, kernelBrowser.SessionID); err != nil {
	panic(err)
}

kernel browsers delete <session-id>

See Termination & timeouts for the full set of teardown options.

Full example

Putting it together — create a browser, run Playwright code inside it, tear down:

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);
}

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)

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 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 shows how to serve your workload from warm, pre-configured browsers instead of creating one per task.

Overview

Working with your browser

deploying your agent

Agent Skills

Integrations

Migrations

Community

Info

Your first browser

Pick the right shape

Headless vs headful

Stealth and proxies

GPU acceleration

Profiles and auth

On demand or from a pool

Lifecycle

Full example

What’s next

​Your first browser

​Pick the right shape

Headless vs headful

Stealth and proxies

GPU acceleration

Profiles and auth

​On demand or from a pool

​Lifecycle

​Full example

​What’s next

Your first browser

Pick the right shape

On demand or from a pool

Lifecycle

Full example

What’s next