> ## Documentation Index
> Fetch the complete documentation index at: https://tbd-6fc993ce-hypeship-scraperly-link.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Create a Browser

> on-demand browsers for your agents

Kernel browsers were designed to be lightweight and fast. Your agent can quickly create them on-demand and tear them down as soon as it is done using them. They can be used as part of the Kernel [app platform](/apps/develop) or connected to from another service with the Chrome DevTools Protocol.

## 1. Create a Kernel browser

<Info>
  First, install the Kernel SDK:

  * Typescript/Javascript: `npm install @onkernel/sdk`
  * Python: `pip install kernel`
</Info>

Use our SDK to create a browser:

<CodeGroup>
  ```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)
  ```
</CodeGroup>

## 2. Connect to the browser

Kernel browsers support three connection methods: CDP for framework-level browser automation, WebDriver BiDi for W3C-standard control, and Computer Controls for OS-level mouse/keyboard input ideal for vision-based LLM loops.

<Tabs>
  <Tab title="CDP">
    Connect with any Chrome DevTools Protocol framework like [Playwright](https://playwright.dev/) or [Puppeteer](https://pptr.dev/). Use `cdp_ws_url` from the created browser session.

    <CodeGroup>
      ```typescript Typescript/Javascript theme={null}
      import { chromium } from 'playwright';

      const browser = await chromium.connectOverCDP(kernelBrowser.cdp_ws_url);
      const context = browser.contexts()[0];
      const page = context.pages()[0];

      await page.goto('https://example.com');
      const title = await page.title();
      console.log(title);
      ```

      ```python Python theme={null}
      from playwright.async_api import async_playwright

      async with async_playwright() as playwright:
          browser = await playwright.chromium.connect_over_cdp(kernel_browser.cdp_ws_url)
          context = browser.contexts[0]
          page = context.pages[0]

          await page.goto('https://example.com')
          title = await page.title()
          print(title)
      ```
    </CodeGroup>
  </Tab>

  <Tab title="WebDriver BiDi">
    Connect with [Vibium](/integrations/vibium) or any WebDriver BiDi-compatible client. Use `webdriver_ws_url` from the created browser session.

    <CodeGroup>
      ```typescript Typescript/Javascript theme={null}
      import { browser } from 'vibium';

      const bro = await browser.start(kernelBrowser.webdriver_ws_url);
      const page = await bro.page();

      await page.goto('https://example.com');
      const title = await page.title();
      console.log(title);
      ```

      ```python Python theme={null}
      from vibium.sync_api import browser

      bro = browser.start(kernel_browser.webdriver_ws_url)
      page = bro.page()

      page.goto('https://example.com')
      title = page.title()
      print(title)
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Computer Controls">
    Control the browser's mouse, keyboard, and screen directly through the Kernel SDK — no CDP or WebDriver connection needed. This is ideal for vision-based LLM loops like [Claude Computer Use](/integrations/computer-use/anthropic).

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

      const kernel = new Kernel();
      const kernelBrowser = await kernel.browsers.create();

      // Take a screenshot
      const response = await kernel.browsers.computer.captureScreenshot(kernelBrowser.session_id);

      // Click at coordinates
      await kernel.browsers.computer.clickMouse(kernelBrowser.session_id, {
        x: 100,
        y: 200,
      });

      // Type text
      await kernel.browsers.computer.typeText(kernelBrowser.session_id, {
        text: 'Hello, World!',
      });
      ```

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

      kernel = Kernel()
      kernel_browser = kernel.browsers.create()

      # Take a screenshot
      screenshot = kernel.browsers.computer.capture_screenshot(id=kernel_browser.session_id)

      # Click at coordinates
      kernel.browsers.computer.click_mouse(
          id=kernel_browser.session_id,
          x=100,
          y=200,
      )

      # Type text
      kernel.browsers.computer.type_text(
          id=kernel_browser.session_id,
          text="Hello, World!",
      )
      ```
    </CodeGroup>
  </Tab>
</Tabs>

## 3. Tear it down

When you're finished with the browser, you can delete it:

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

  const kernel = new Kernel();

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

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

  kernel = Kernel()
  await kernel.browsers.delete_by_id(kernel_browser.session_id)
  ```
</CodeGroup>

Browsers automatically delete after a timeout (default 60 seconds) if they don't receive a CDP or live view connection. You can [configure this timeout](/browsers/termination#automatic-deletion-via-timeout) when creating the browser.

## Full example

Once you've connected to the Kernel browser, you can do anything with it.

<Info>
  Kernel browsers launch with a default context and page. Make sure to access
  the [existing context and
  page](https://playwright.dev/docs/api/class-browsertype#browser-type-connect-over-cdp)
  (`contexts()[0]` and `pages()[0]`), rather than trying to create a new one.
</Info>

<CodeGroup>
  ```typescript Typescript/Javascript theme={null}
  import Kernel from '@onkernel/sdk';
  import { chromium } from 'playwright';

  const kernel = new Kernel();

  const kernelBrowser = await kernel.browsers.create();
  const browser = await chromium.connectOverCDP(kernelBrowser.cdp_ws_url);

  try {
    const context = browser.contexts()[0] || (await browser.newContext());
    const page = context.pages()[0] || (await context.newPage());
    await page.goto('https://www.onkernel.com');
    const title = await page.title();
  } catch (error) {
    console.error(error);
  } finally {
    await browser.close();
    await kernel.browsers.deleteByID(kernelBrowser.session_id);
  }
  ```

  ```python Python theme={null}
  from kernel import Kernel
  from playwright.async_api import async_playwright

  kernel = Kernel()

  kernel_browser = kernel.browsers.create()

  async with async_playwright() as playwright:
      browser = await playwright.chromium.connect_over_cdp(kernel_browser.cdp_ws_url)

      try:
          context = browser.contexts[0] if browser.contexts else await browser.new_context()
          page = context.pages[0] if context.pages else await context.new_page()
          await page.goto('https://www.onkernel.com')
          title = await page.title()
      except Exception as e:
          print(e)
      finally:
          await browser.close()
          await kernel.browsers.delete_by_id(kernel_browser.session_id)
  ```
</CodeGroup>