Kernel

https://www.kernel.sh/docs
Admin
Kernel is a developer platform providing Browsers-as-a-Service for web agents and automations,...
Tokens:1,107,854
Snippets:6,418
Trust Score:5.6
Update:9 hours ago
Show doc for...
Tokens:
Raw
### Setup profile example

Source: https://www.kernel.sh/docs/reference/mcp-server/tools/manage-profiles

Example of the setup action with profile_name 'work-accounts'. This creates or updates a browser profile with the given name, following the naming rules: 1-255 characters using ASCII letters, numbers, dots, underscores, or hyphens, unique within the project, and not exactly 24 lowercase alphanumeric characters.

```json
{
  "action": "setup",
  "profile_name": "work-accounts"
}
```

--------------------------------

### Go example for starting a browser replay

Source: https://www.kernel.sh/docs/api-reference/browser-replays/start-a-browser-session-replay-recording

Uses net/http to POST the replay configuration. Prints the response body.

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.onkernel.com/browsers/{id_or_name}/replays"

	payload := strings.NewReader("{\n  \"framerate\": 30,\n  \"max_duration_in_seconds\": 2,\n  \"record_audio\": false\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Install Kernel SDK for TypeScript, Python, and Go

Source: https://www.kernel.sh/docs/start/quickstart

Install the SDK using the package manager for your language. The commands are npm install @onkernel/sdk, pip install kernel, and go get github.com/kernel/kernel-go-sdk.

```bash
npm install @onkernel/sdk
```

```bash
pip install kernel
```

```bash
go get github.com/kernel/kernel-go-sdk
```

--------------------------------

### Go example for file info

Source: https://www.kernel.sh/docs/api-reference/browser-filesystem/get-information-about-a-file-or-directory

Uses net/http to GET file or directory information. Prints the response body.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.onkernel.com/browsers/{id_or_name}/fs/file_info"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Go GET request to fetch a project

Source: https://www.kernel.sh/docs/api-reference/projects/get-a-project-by-id-or-name-1

Go example using net/http to fetch a project. Creates a GET request with the Authorization header and prints the response body.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.onkernel.com/projects/{id_or_name}"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Go GET request to list apps

Source: https://www.kernel.sh/docs/api-reference/apps/list-apps

Go example using net/http to list apps. It creates a GET request to https://api.onkernel.com/apps with an Authorization header and prints the response body.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.onkernel.com/apps"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Download audit logs with Go SDK

Source: https://www.kernel.sh/docs/info/audit-logs

Uses the kernel-go-sdk to download audit logs to a file. The helper defaults to jsonl.gz and writes to the provided destination. The destination is not closed by the helper, so it must be closed manually. The example filters out GET methods and specifies a start and end time.

```go
package main

import (
	"context"
	"os"
	"time"

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

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

	file, err := os.Create("audit-logs.jsonl.gz")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	_, err = client.AuditLogs.Download(ctx, kernel.AuditLogDownloadParams{
		Start:         time.Date(2026, time.June, 1, 0, 0, 0, 0, time.UTC),
		End:           time.Date(2026, time.June, 2, 0, 0, 0, 0, time.UTC),
		ExcludeMethod: []string{"GET"},
	}, file)
	if err != nil {
		panic(err)
	}
}
```

--------------------------------

### Complete hosted UI authentication example (Go)

Source: https://www.kernel.sh/docs/auth/hosted-ui

Full flow: create connection, start login, print hosted URL, stream state changes, and on SUCCESS create a browser with the profile and navigate. Requires kernel-go-sdk.

```Go
package main

import (
	"context"
	"fmt"

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

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

	// Create connection
	auth, err := client.Auth.Connections.New(ctx, kernel.AuthConnectionNewParams{
		ManagedAuthCreateRequest: kernel.ManagedAuthCreateRequestParam{
			Domain:      "doordash.com",
			ProfileName: "doordash-user-123",
		},
	})
	if err != nil {
		panic(err)
	}

	// Start authentication
	login, err := client.Auth.Connections.Login(ctx, auth.ID, kernel.AuthConnectionLoginParams{})
	if err != nil {
		panic(err)
	}

	// Send user to hosted page
	fmt.Println("Login URL:", login.HostedURL)

	// Stream state changes until the flow completes
	events := client.Auth.Connections.FollowStreaming(ctx, auth.ID)
	authenticated := false
	for events.Next() {
		event := events.Current()
		if event.Event == "managed_auth_state" && event.FlowStatus == "SUCCESS" {
			authenticated = true
		}
	}
	if err := events.Err(); err != nil {
		panic(err)
	}

	if authenticated {
		browser, err := client.Browsers.New(ctx, kernel.BrowserNewParams{
			Profile: shared.BrowserProfileParam{
				Name: kernel.String("doordash-user-123"),
			},
			Stealth: kernel.Bool(true),
		})
		if err != nil {
			panic(err)
		}

		// Navigate with the saved authentication state
		_, err = client.Browsers.Playwright.Execute(ctx, browser.SessionID, kernel.BrowserPlaywrightExecuteParams{
			Code: `await page.goto("https://doordash.com");`,
		})
		if err != nil {
			panic(err)
		}
	}
}
```

--------------------------------

### Download audit logs with Python SDK

Source: https://www.kernel.sh/docs/info/audit-logs

Uses the Python SDK to download audit logs to a file. The helper defaults to jsonl.gz and writes to the provided destination. The destination is not closed by the helper, so it must be closed manually. The example filters out GET methods and specifies a start and end time.

```python
import os
from kernel import Kernel

client = Kernel(api_key=os.environ["KERNEL_API_KEY"])

with open("audit-logs.jsonl.gz", "wb") as file:
    client.audit_logs.download(
        to=file,
        start="2026-06-01T00:00:00Z",
        end="2026-06-02T00:00:00Z",
        exclude_method=["GET"],
    )
```

--------------------------------

### Kernel CLI Quick Start

Source: https://www.kernel.sh/docs/reference/cli

Create a new app, log in, deploy, and invoke an action. The payload is passed as a JSON string.

```bash
# 1) Create a new app
kernel create

# 2) Login
kernel login

# 3) Deploy your app
kernel deploy index.ts

# 4) Invoke your app
kernel invoke my-app action-name --payload '{"key":"value"}'
```

--------------------------------

### Create a browser with Go SDK

Source: https://www.kernel.sh/docs/introduction/create

Install the SDK with `go get github.com/kernel/kernel-go-sdk`, then create a client and call `client.Browsers.New`. The response includes `session_id`, `cdp_ws_url`, `webdriver_ws_url`, and `browser_live_view_url`.

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

--------------------------------

### Download audit logs with TypeScript SDK

Source: https://www.kernel.sh/docs/info/audit-logs

Uses the @onkernel/sdk TypeScript SDK to download audit logs to a file. The helper defaults to jsonl.gz and writes to the provided destination. The destination is not closed by the helper, so it must be closed manually. The example filters out GET methods and specifies a start and end time.

```typescript
import { open } from 'node:fs/promises';
import Kernel from '@onkernel/sdk';

const kernel = new Kernel({
  apiKey: process.env.KERNEL_API_KEY,
});

const file = await open('audit-logs.jsonl.gz', 'w');
try {
  await kernel.auditLogs.download(
    {
      start: '2026-06-01T00:00:00Z',
      end: '2026-06-02T00:00:00Z',
      exclude_method: ['GET'],
    },
    file,
  );
} finally {
  await file.close();
}
```

--------------------------------

### Complete hosted UI authentication example (Python)

Source: https://www.kernel.sh/docs/auth/hosted-ui

Full flow: create connection, start login, print hosted URL, stream state changes, and on SUCCESS create a browser with the profile and navigate. Requires kernel AsyncKernel.

```Python
from kernel import AsyncKernel

kernel = AsyncKernel()

# Create connection
auth = await kernel.auth.connections.create(
    domain="doordash.com",
    profile_name="doordash-user-123",
)

# Start authentication
login = await kernel.auth.connections.login(auth.id)

# Send user to hosted page
print(f"Login URL: {login.hosted_url}")

# Stream state changes until the flow completes
events = await kernel.auth.connections.follow(auth.id)
final_state = None
async for event in events:
    if event.event == "managed_auth_state":
        final_state = event

if final_state and final_state.flow_status == "SUCCESS":
    browser = await kernel.browsers.create(
        profile={"name": "doordash-user-123"},
        stealth=True,
    )
    
    # Navigate with the saved authentication state
    await page.goto("https://doordash.com")
```

--------------------------------

### Start a replay recording

Source: https://www.kernel.sh/docs/reference/mcp-server/tools/manage-replays

Example request to start a replay recording for a session, with a maximum duration of 300 seconds.

```json
{
  "action": "start",
  "session_id": "session_abc123",
  "max_duration_in_seconds": 300
}
```

--------------------------------

### Start, Stop, and Download Replay (CLI)

Source: https://www.kernel.sh/docs/introduction/observe

Example of starting, stopping, and downloading a replay using the Kernel CLI.

```APIDOC
## Start Replay

### Description
Starts a replay for a browser session.

### Method
`kernel browsers replays start`

### Parameters
- `<session-id>` (string) - Required - The ID of the browser session to record.

### Example
```bash
kernel browsers replays start <session-id>
```

## Stop Replay

### Description
Stops an active replay.

### Method
`kernel browsers replays stop`

### Parameters
- `<session-id>` (string) - Required - The ID of the browser session.
- `<replay-id>` (string) - Required - The ID of the replay to stop.

### Example
```bash
kernel browsers replays stop <session-id> <replay-id>
```

## Download Replay

### Description
Downloads the recorded replay as an MP4 file.

### Method
`kernel browsers replays download`

### Parameters
- `<session-id>` (string) - Required - The ID of the browser session.
- `<replay-id>` (string) - Required - The ID of the replay to download.
- `-o` (string) - Required - Output file path for the MP4.

### Example
```bash
kernel browsers replays download <session-id> <replay-id> -o replay.mp4
```
```

--------------------------------

### Create browser with profile and start_url (Go)

Source: https://www.kernel.sh/docs/browsers/profiles/save-and-reuse

Creates a browser with a profile named 'checkout-session' and sets the starting tab to 'https://example.com/dashboard'. This discards any restored tabs.

```Go
browser, err := client.Browsers.New(ctx, kernel.BrowserNewParams{
	Profile: shared.BrowserProfileParam{
		Name: kernel.String("checkout-session"),
	},
	StartURL: kernel.String("https://example.com/dashboard"),
})
if err != nil {
	panic(err)
}
```

--------------------------------

### Install dependencies for WebMCP code mode

Source: https://www.kernel.sh/docs/browsers/code-mode-webmcp

Install the required npm packages for the example: ai, @ai-sdk/openai, @ai-sdk/mcp, @onkernel/sdk, and tsx.

```bash
npm install ai @ai-sdk/openai @ai-sdk/mcp @onkernel/sdk tsx
```

--------------------------------

### Setup only (--setup-only)

Source: https://www.kernel.sh/docs/browsers/ssh

Configure SSH on the VM without opening a connection. Installs and configures the SSH server, then prints the manual connection command.

```bash
kernel browsers ssh <session-id> --setup-only
```

--------------------------------

### Java Unirest GET to /auth/connections/{id}

Source: https://www.kernel.sh/docs/api-reference/managed-auth/get-auth-connection

Java example using Unirest to GET an auth connection. Returns an HttpResponse<String>.

```java
HttpResponse<String> response = Unirest.get("https://api.onkernel.com/auth/connections/{id}")
  .header("Authorization", "Bearer <token>")
  .asString();
```

--------------------------------

### Go GET request to /auth/connections/{id}

Source: https://www.kernel.sh/docs/api-reference/managed-auth/get-auth-connection

Go example using net/http to GET an auth connection. Prints the response body.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.onkernel.com/auth/connections/{id}"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Complete hosted UI authentication example (TypeScript)

Source: https://www.kernel.sh/docs/auth/hosted-ui

Full flow: create connection, start login, print hosted URL, stream state changes, and on SUCCESS create a browser with the profile and navigate. Requires @onkernel/sdk.

```TypeScript
import Kernel from '@onkernel/sdk';

const kernel = new Kernel();

// Create connection
const auth = await kernel.auth.connections.create({
  domain: 'doordash.com',
  profile_name: 'doordash-user-123',
});

// Start authentication
const login = await kernel.auth.connections.login(auth.id);

// Send user to hosted page
console.log('Login URL:', login.hosted_url);

// Stream state changes until the flow completes
const events = await kernel.auth.connections.follow(auth.id);
let finalState;
for await (const event of events) {
  if (event.event === 'managed_auth_state') {
    finalState = event;
  }
}

if (finalState?.flow_status === 'SUCCESS') {
  const browser = await kernel.browsers.create({
    profile: { name: 'doordash-user-123' },
    stealth: true,
  });
  
  // Navigate with the saved authentication state
  await page.goto('https://doordash.com');
}
```

--------------------------------

### Include GET requests in audit log search

Source: https://www.kernel.sh/docs/reference/cli/audit-logs

Two examples: one returns all matching methods including GET using --include-get, the other returns only GET requests using --method GET. By default, GET is excluded unless --include-get is passed.

```bash
# Return all matching methods, including GET
kernel audit-logs search --include-get
```

```bash
# Return only GET requests
kernel audit-logs search --method GET
```

--------------------------------

### PHP cURL GET to /auth/connections/{id}

Source: https://www.kernel.sh/docs/api-reference/managed-auth/get-auth-connection

PHP example using cURL to GET an auth connection. Outputs the response or a cURL error.

```php
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.onkernel.com/auth/connections/{id}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

--------------------------------

### Response: 200 OK

Source: https://www.kernel.sh/docs/api-reference/config-registry/list-configs

Example successful response containing a list of configuration objects with analysis details and recommendation.

```json
[
  {
    "analysis_id": "<string>",
    "analysis_status": "running",
    "last_requested_at": "2023-11-07T05:31:56Z",
    "recommendation": {
      "browser": {
        "gpu": true,
        "headless": true,
        "stealth": true,
        "viewport": {
          "height": 800,
          "width": 1280,
          "refresh_rate": 60
        }
      },
      "evidence": {
        "accessed": 1,
        "blocked": 1,
        "inconclusive": 1,
        "last_observed_at": "2023-11-07T05:31:56Z",
        "run_count": 1,
        "sample_size": 1,
        "success_rate": 0.5,
        "last_supported_at": "2023-11-07T05:31:56Z"
      },
      "match_scope": "exact",
      "matched_target": "<string>",
      "proxy": {
        "mode": "direct"
      },
      "type": "recommendation"
    },
    "recommended_config_label": "<string>",
    "success_rate": 0.5,
    "target": "<string>"
  }
]
```

--------------------------------

### Go: Login, follow, and browser creation

Source: https://www.kernel.sh/docs/auth/connection-lifecycle

Go example of the pre-task authentication check. Calls `Login`, follows the streaming events, sets `authenticated` on `SUCCESS`, panics if user action is required at `HostedURL`, and then creates a browser with a profile named 'github-profile'.

```Go
login, err := client.Auth.Connections.Login(ctx, auth.ID, kernel.AuthConnectionLoginParams{})
if err != nil {
	panic(err)
}

events := client.Auth.Connections.FollowStreaming(ctx, auth.ID)
authenticated := false
for events.Next() {
	event := events.Current()
	if event.Event != "managed_auth_state" {
		continue
	}

	if event.FlowStatus == "SUCCESS" {
		authenticated = true
		break
	}

	if event.FlowStep == "AWAITING_INPUT" || event.FlowStep == "AWAITING_EXTERNAL_ACTION" {
		panic("user action required at " + login.HostedURL)
	}
}
if err := events.Err(); err != nil {
	panic(err)
}
if !authenticated {
	panic("authentication did not complete successfully")
}

kernelBrowser, err := client.Browsers.New(ctx, kernel.BrowserNewParams{
	Profile: shared.BrowserProfileParam{
		Name: kernel.String("github-profile"),
	},
})
if err != nil {
	panic(err)
}
_ = kernelBrowser
```

--------------------------------

### JavaScript fetch GET to /auth/connections/{id}

Source: https://www.kernel.sh/docs/api-reference/managed-auth/get-auth-connection

JavaScript example using fetch to GET an auth connection. Logs the response JSON or an error.

```javascript
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.onkernel.com/auth/connections/{id}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```

--------------------------------

### Hot-swap browser proxy (Go)

Source: https://www.kernel.sh/docs/proxies/overview

Go equivalent of the hot-swap example: creates two proxies, launches a browser with the first, then updates to the second and finally removes the proxy. The update is synchronous and completes in 2-3 seconds.

```go
package main

import (
	"context"

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

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

	// Create two proxy configurations
	proxyA, err := client.Proxies.New(ctx, kernel.ProxyNewParams{
		Type: kernel.ProxyNewParamsTypeIsp,
		Name: kernel.String("proxy-a"),
		Config: kernel.ProxyNewParamsConfigUnion{
			OfProxyNewsConfigIspProxyConfig: &kernel.ProxyNewParamsConfigIspProxyConfig{
				Country: kernel.String("US"),
			},
		},
	})
	if err != nil {
		panic(err)
	}

	proxyB, err := client.Proxies.New(ctx, kernel.ProxyNewParams{
		Type: kernel.ProxyNewParamsTypeResidential,
		Name: kernel.String("proxy-b"),
		Config: kernel.ProxyNewParamsConfigUnion{
			OfProxyNewsConfigResidentialProxyConfig: &kernel.ProxyNewParamsConfigResidentialProxyConfig{
				Country: kernel.String("DE"),
			},
		},
	})
	if err != nil {
		panic(err)
	}

	// Launch a browser with the first proxy
	browser, err := client.Browsers.New(ctx, kernel.BrowserNewParams{
		ProxyID: kernel.String(proxyA.ID),
	})
	if err != nil {
		panic(err)
	}

	// Hot-swap to a different proxy
	if _, err := client.Browsers.Update(ctx, browser.SessionID, kernel.BrowserUpdateParams{
		ProxyID: kernel.String(proxyB.ID),
	}); err != nil {
		panic(err)
	}

	// Remove the proxy entirely (route directly to the internet)
	if _, err := client.Browsers.Update(ctx, browser.SessionID, kernel.BrowserUpdateParams{
		ProxyID: kernel.String(""),
	}); err != nil {
		panic(err)
	}
}
```

--------------------------------

### Ruby Net::HTTP GET to /auth/connections/{id}

Source: https://www.kernel.sh/docs/api-reference/managed-auth/get-auth-connection

Ruby example using Net::HTTP to GET an auth connection. Prints the response body.

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.onkernel.com/auth/connections/{id}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

--------------------------------

### Start a login session on the backend (Go)

Source: https://www.kernel.sh/docs/auth/react

Create a connection and start a login using the Kernel SDK in Go. The login response includes ID and HandoffCode.

```go
auth, err := client.Auth.Connections.New(ctx, kernel.AuthConnectionNewParams{
	ManagedAuthCreateRequest: kernel.ManagedAuthCreateRequestParam{
		Domain:      "netflix.com",
		ProfileName: "user-123",
	},
})
if err != nil {
	panic(err)
}

login, err := client.Auth.Connections.Login(ctx, auth.ID, kernel.AuthConnectionLoginParams{})
if err != nil {
	panic(err)
}
fmt.Println(login.ID, login.HandoffCode)
```

--------------------------------

### Start Login Flow with PHP cURL

Source: https://www.kernel.sh/docs/api-reference/managed-auth/start-login-flow

Use this PHP example to start a login flow by sending a POST request to the OnKernel API endpoint using cURL. It includes the same browser telemetry and proxy configuration as the JavaScript example. The request requires a Bearer token and returns a JSON response.

```php
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.onkernel.com/auth/connections/{id}/login",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'browser' => [
        'proxy' => [
                'id' => '<string>',
                'name' => '<string>'
        ],
        'stealth' => false,
        'telemetry' => [
                'browser' => [
                                'captcha' => [
                                                                'enabled' => true
                                ],
                                'connection' => [
                                                                'enabled' => true
                                ],
                                'console' => [
                                                                'enabled' => true
                                ],
                                'control' => [
                                                                'cdp' => [
                                                                                                                                'excluded_methods' => [
                                                                                                                                                                                                
                                                                                                                                ]
                                                                ],
                                                                'enabled' => true
                                ],
                                'interaction' => [
                                                                'enabled' => true
                                ],
                                'network' => [
                                                                'enabled' => true
                                ],
                                'page' => [
                                                                'enabled' => true
                                ],
                                'platform' => [
                                                                'enabled' => true
                                ],
                                'screenshot' => [
                                                                'enabled' => true
                                ],
                                'system' => [
                                                                'enabled' => true
                                ]
                ],
                'enabled' => true,
                'export' => [
                                'otlp' => [
                                                                'destination' => [
                                                                                                                                'id' => '<string>',

```

--------------------------------

### Load profile with start_url (Go)

Source: https://www.kernel.sh/docs/browsers/profiles/save-and-reuse

Loads a profile and sets the starting tab to 'https://example.com/dashboard' in the same update call, collapsing restored tabs to a single tab.

```Go
_, err = client.Browsers.Update(ctx, browser.SessionID, kernel.BrowserUpdateParams{
	Profile: shared.BrowserProfileParam{
		Name: kernel.String("checkout-session"),
	},
	StartURL: kernel.String("https://example.com/dashboard"),
})
if err != nil {
	panic(err)
}
```

--------------------------------

### Create a project with Go

Source: https://www.kernel.sh/docs/api-reference/projects/create-a-project-1

Uses the net/http package to send a POST request with a JSON body. Prints the response body.

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.onkernel.com/projects"

	payload := strings.NewReader("{\n  \"name\": \"staging\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Python requests GET to /auth/connections/{id}

Source: https://www.kernel.sh/docs/api-reference/managed-auth/get-auth-connection

Python example using the requests library to GET an auth connection. Requires the requests package and a valid bearer token.

```python
import requests

url = "https://api.onkernel.com/auth/connections/{id}"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.text)
```

--------------------------------

### Start a login session (TypeScript, Python, Go)

Source: https://www.kernel.sh/docs/auth/hosted-ui

Starts a Managed Auth Session to get the hosted login URL. The returned login object contains the hosted_url.

```TypeScript
const login = await kernel.auth.connections.login(auth.id);
```

```Python
login = await kernel.auth.connections.login(auth.id)
```

```Go
login, err := client.Auth.Connections.Login(ctx, auth.ID, kernel.AuthConnectionLoginParams{})
if err != nil {
	panic(err)
}
_ = login
```

--------------------------------

### Create a browser with Python SDK

Source: https://www.kernel.sh/docs/introduction/create

Install the SDK with `pip install kernel`, then instantiate the Kernel client and call `kernel.browsers.create()`. The response includes `session_id`, `cdp_ws_url`, `webdriver_ws_url`, and `browser_live_view_url`.

```python
from kernel import Kernel

kernel = Kernel()

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

--------------------------------

### Create a browser with TypeScript/JavaScript SDK

Source: https://www.kernel.sh/docs/introduction/create

Install the SDK with `npm install @onkernel/sdk`, then instantiate the Kernel client and call `kernel.browsers.create()`. The response includes `session_id`, `cdp_ws_url`, `webdriver_ws_url`, and `browser_live_view_url`.

```typescript
import Kernel from '@onkernel/sdk';

const kernel = new Kernel();

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

--------------------------------

### Response: Successful replay start (201)

Source: https://www.kernel.sh/docs/api-reference/browser-replays/start-a-browser-session-replay-recording

Example JSON response returned when the replay recording is successfully started. Contains replay_id, started_at, finished_at, and replay_view_url fields.

```json
{
  "replay_id": "<string>",
  "finished_at": "2023-11-07T05:31:56Z",
  "replay_view_url": "https://api.onkernel.com/browser/replays?jwt=eyJ0eXAi...&replay_id=7e2c1a9f-1234-4cde-9abc-ffeedd001122",
  "started_at": "2023-11-07T05:31:56Z"
}

```

--------------------------------

### Go example for config lookup

Source: https://www.kernel.sh/docs/api-reference/config-registry/look-up-a-config

Uses net/http to POST the lookup payload with headers and prints the response body.

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.onkernel.com/config-registry/lookup"

	payload := strings.NewReader("{\n  \"url\": \"<string>\",\n  \"allowed_proxy_countries\": [\n    \"US\"\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Java Unirest GET request to fetch a project

Source: https://www.kernel.sh/docs/api-reference/projects/get-a-project-by-id-or-name-1

Java example using Unirest to fetch a project. Sends a GET request with the Authorization header and returns the response as a string.

```java
HttpResponse<String> response = Unirest.get("https://api.onkernel.com/projects/{id_or_name}")
  .header("Authorization", "Bearer <token>")
  .asString();
```

--------------------------------

### Create headless browser with Kernel SDK (Go)

Source: https://www.kernel.sh/docs/browsers/headless

Use this Go example to create a Kernel browser in headless mode by setting `Headless: kernel.Bool(true)` in the `BrowserNewParams`. This is the Go SDK equivalent for headless automation.

```go
package main

import (
	"context"

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

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

	kernelBrowser, err := client.Browsers.New(ctx, kernel.BrowserNewParams{
		Headless: kernel.Bool(true),
	})
	if err != nil {
		panic(err)
	}
	_ = kernelBrowser
}
```

--------------------------------

### Install Kernel MCP for Windsurf using CLI

Source: https://www.kernel.sh/docs/reference/mcp-server/clients/windsurf

Recommended command to install the Kernel MCP server for Windsurf. After running, compare the installed entry with the manual example and add any missing OAuth metadata, callback port, or cache directory before authorizing.

```bash
kernel mcp install --target windsurf
```

--------------------------------

### Initialize Kernel and create a browser (v3)

Source: https://www.kernel.sh/docs/integrations/stagehand

Imports the libraries and creates a cloud browser session with stealth mode. Logs the live view URL.

```typescript
import { Stagehand } from "@browserbasehq/stagehand";
import Kernel from "@onkernel/sdk";
import { z } from "zod";

const kernel = new Kernel();

const kernelBrowser = await kernel.browsers.create({ stealth: true });

console.log("Live view url: ", kernelBrowser.browser_live_view_url);
```

--------------------------------

### Java Unirest GET to list apps

Source: https://www.kernel.sh/docs/api-reference/apps/list-apps

Java example using Unirest to list apps. It sends a GET request to https://api.onkernel.com/apps with an Authorization header and returns the response as a string.

```java
HttpResponse<String> response = Unirest.get("https://api.onkernel.com/apps")
  .header("Authorization", "Bearer <token>")
  .asString();
```
Tokens:
Raw