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

# Notte

[Notte](https://www.notte.cc/) is an AI agent framework that enables you to build sophisticated browser automation tasks. By integrating with Kernel, you can run Notte agents with cloud-hosted browsers using Chrome DevTools Protocol (CDP).

## Adding Kernel to existing Notte implementations

If you already have a Notte implementation, you can easily switch to using Kernel's cloud browsers by connecting via CDP.

### 1. Install the Kernel SDK

```bash theme={null}
uv pip install kernel
```

### 2. Initialize Kernel and create a browser

Import the libraries and create a cloud browser session:

```python theme={null}
from kernel import Kernel
from notte_sdk import NotteClient

# Initialize clients
kernel = Kernel()
notte_client = NotteClient(api_key="your-notte-api-key")

# Create a browser on Kernel
kernel_browser = kernel.browsers.create()
```

### 3. Connect Notte to Kernel's CDP endpoint

Use Kernel's CDP URL to create a Notte session:

```python theme={null}
# Connect Notte to Kernel's browser via CDP
with notte_client.Session(cdp_url=kernel_browser.cdp_ws_url) as session:
    # Create an agent with a task
    agent = notte_client.Agent(session=session, max_steps=10)

    # Run your automation task
    result = agent.run(
        task="extract pricing plans from https://www.notte.cc"
    )
```

### 4. Clean up the browser session

After your automation completes, clean up the Kernel browser:

```python theme={null}
kernel.browsers.delete_by_id(kernel_browser.session_id)
```

## Complete example script

Here's a complete, runnable script that demonstrates the full integration:

```python theme={null}
from kernel import Kernel
from notte_sdk import NotteClient
import os
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

def main():
    # Initialize clients
    kernel = Kernel()
    
    notte_api_key = os.getenv("NOTTE_API_KEY")
    if not notte_api_key:
        raise ValueError("NOTTE_API_KEY not found in environment variables")
    
    notte_client = NotteClient(api_key=notte_api_key)

    # Create a headful browser on Kernel
    print("Creating browser session on Kernel...")
    kernel_browser = kernel.browsers.create()
    # print(kernel_browser.browser_live_view_url)

    try:
        # Connect Notte to Kernel's browser via CDP
        print("Connecting Notte to Kernel browser...")
        with notte_client.Session(cdp_url=kernel_browser.cdp_ws_url) as session:
            # Create an agent with a task
            agent = notte_client.Agent(session=session, max_steps=10)

            # Run your automation task
            result = agent.run(
                task="extract pricing plans from https://www.notte.cc"
            )

            print(f"Task completed: {result.answer}")

    except Exception as e:
        print(f"Error during automation: {e}")

    finally:
        # Always clean up the browser session
        kernel.browsers.delete_by_id(kernel_browser.session_id)
        print("Browser session cleaned up")

if __name__ == "__main__":
    main()
```

## Benefits of using Kernel with Notte

* **No local browser management**: Run agents without installing or maintaining browsers locally
* **Scalability**: Launch multiple browser sessions in parallel for concurrent tasks
* **Cloud infrastructure**: Leverage Kernel's optimized browser infrastructure
* **Stealth mode**: Built-in anti-detection features for web scraping
* **Session control**: Programmatic control over browser lifecycle

## Next steps

* Learn about [creating browsers](/introduction/create) on Kernel
* Check out [live view](/browsers/live-view) for debugging your automations
* Learn about [stealth mode](/browsers/bot-detection/stealth) for avoiding detection
* Explore [Profiles](/auth/profiles) for maintaining browser state across sessions