Notte Browser

Notte Browser CLI Skill

Command-line interface for launching and controlling Notte cloud browser sessions, scraping pages, managing browser credentials, and deploying reusable browser workflows as Notte Functions. A Function is the deployment form of a tested browser task: it can be invoked later as an HTTP API endpoint, run from the CLI/SDK, or scheduled.

General Documentation

For broader Notte concepts, current docs, and internet-search entry points, start with the documentation index:

https://docs.notte.cc/llms.txt

CLI vs. the bundled MCP servers

The notte plugin also ships two hosted MCP servers. Prefer the CLI for everything in this skill - it is the interface these instructions are written against. Reach for the MCP servers only in the cases below:

anything-api exposes search (browse the marketplace, no auth), spec (get a function's variable schema), run, and build (natural language -> a new deployed Function, 2-10 minutes). build and run need authentication - OAuth via your client, or Authorization: Bearer $NOTTE_API_KEY. Browse it visually at https://anything.notte.cc/marketplace.

Both servers authenticate independently of notte auth login; a working CLI session does not imply a working MCP connection, and vice versa.

Setup

Use this skill after the notte CLI is installed. It assumes CLI v0.0.41 or newer. v0.0.30 renamed the list filter flags (--include-deleted, -a/--all, --running) and made notte functions runs return the full history by default; v0.0.31 adds --no-solve-captchas; v0.0.33 adds named --vault-field credential fills; v0.0.41 makes file upload, listing, and download session-scoped and addresses files by immutable ID. Check with notte version and upgrade if it is older; the commands below will not all work otherwise.

If authentication is missing, run the interactive CLI login flow and wait for it to complete.

# Install with Homebrew
brew tap nottelabs/notte-cli https://github.com/nottelabs/notte-cli.git
brew install notte

# Or install with Go
go install github.com/nottelabs/notte-cli/cmd/notte@latest

# Authenticate locally, or set NOTTE_API_KEY for CI/non-interactive agents
notte auth login
# export NOTTE_API_KEY=...
notte auth status

# Install this skill into the assistant's config, and remove it again
notte skill add
# notte skill remove

# Clear the stored credentials when handing the machine over
# notte auth logout

Authentication Handling

Missing authentication is an interactive setup step, not a blocker and not a reason to switch to SDK code.

If notte auth status reports that authentication is missing, you MUST run:

notte auth login

Tell the user to complete the browser login flow. Then poll authentication status every 5 seconds for up to 5 minutes:

notte auth status

Do not write SDK code, switch to SDK docs, or build a fallback script because auth is missing. SDK code uses the same Notte authentication and does not solve this problem. Continue only after CLI authentication succeeds, or ask the user for help if login does not complete after 5 minutes.

Quick Start

# 1. Authenticate. If this opens a browser login, wait for the user to finish.
notte auth login
notte auth status

# 2. Start a browser session and capture its ID
SESSION_ID=$(notte sessions start -o json | jq -r '.session_id')

# 3. Goto and observe
notte page goto --session-id "$SESSION_ID" "https://example.com"
notte page observe --session-id "$SESSION_ID"
notte page screenshot --session-id "$SESSION_ID"

# 4. Execute actions (use IDs from observe, or Playwright selectors)
notte page click --session-id "$SESSION_ID" "B3"
notte page fill --session-id "$SESSION_ID" "I1" "hello world"
# If observe IDs don't work, use Playwright selectors:
# notte page click --session-id "$SESSION_ID" "button:has-text('Submit')"

# 5. Scrape content
notte page scrape --session-id "$SESSION_ID" --instructions "Extract all product names and prices"

# 6. Stop the session
notte sessions stop --session-id "$SESSION_ID"

Command Categories

Session Management

Control browser session lifecycle:

# Start a new session
notte sessions start [flags]
  --browser-type <type>      chromium (default) or chrome. chrome-nightly and
                             chrome-turbo are legacy aliases for chrome.
  --idle-timeout-minutes     Idle timeout in minutes (default: 3)
  --max-duration-minutes     Maximum session lifetime in minutes (default: 15)
  --proxy                    Use default proxies
  --proxy-country <code>     Proxy country code (e.g. us, gb, fr). Implies --proxy
  --no-solve-captchas        Turn OFF captcha solving (it is on by default)
  --vault-id <vault-id>      Attach a vault so --vault-field fills resolve (see below)
  --profile-id <profile-id>  Load browser state from a profile
  --profile-persist          Save browser state back to the profile on session close
  --viewport-width           Viewport width in pixels
  --viewport-height          Viewport height in pixels
  --aspect-ratio <ratio>     Viewport shape preset; cannot be combined with
                             explicit --viewport-width/--viewport-height
  --user-agent               Custom user agent string
  --cdp-url                  CDP URL of remote session provider
  --screenshot-type <type>   raw, full, or last_action
  --chrome-args              Override the Chrome instance arguments (repeatable)
  --extra-http-headers       Extra HTTP headers as JSON
  --web-bot-auth             Use web bot authentication

# Bring your own proxy instead of Notte's pool
  --proxy-external-server <url>        e.g. http://proxy:8080. Enables external proxy
  --proxy-external-username <user>
  --proxy-external-password <pass>
  --proxy-tailnet-client-id <id>       Tailnet OAuth client ID. Enables Tailscale proxy
  --proxy-tailnet-client-secret <secret>

# Get session status
notte sessions status --session-id <session-id>

# Stop a session
notte sessions stop --session-id <session-id>

# List sessions (with optional pagination and filters)
notte sessions list [--page N] [--page-size N] [-a|--all]   # running only; -a includes stopped

Sessions expire sooner than you might expect. A session closes after 3 minutes idle or 15 minutes total, whichever comes first. Long exploration, a slow login, or a pause for user confirmation can all outlast that, and the next command then fails with Session closed rather than anything descriptive. Raise both when the task will not finish quickly:

notte sessions start --idle-timeout-minutes 15 --max-duration-minutes 60

Skill rule: Always save the session_id returned by sessions start and pass it as --session-id to every page, targeted sessions, and session-file command. Do not rely on the CLI's current-session or environment-variable fallback behavior.

Browser profiles: Profiles store browser state such as cookies, localStorage, and sessionStorage. Start a session with --profile-id <profile-id> to load that saved state; add --profile-persist when starting the session if changes should be saved back to the profile when the session closes.

Session debugging:

# Download the network logs (HAR) to a folder and print the path.
# --urls-only prints just the request URLs inline instead of downloading.
# --path <dir> chooses the output directory (defaults to a temp directory).
notte sessions network --session-id <session-id> [--urls-only] [--path <dir>]

# Download the session replay video
notte sessions replay --session-id <session-id>

# Open the live session viewer in your browser
notte sessions viewer --session-id <session-id>

# Get session offset info (the step index agents resume from)
notte sessions offset --session-id <session-id>

Session export:

# Export session steps as Python workflow code.
# Use --session-id to export a specific session, including one that has been stopped.
notte sessions workflow-code --session-id <session-id>

# `notte sessions code --session-id <session-id>` hits the same endpoint without the workflow wrapper and
# returns a plain replay script. Prefer `workflow-code` when the target is a
# Notte Function - it is the shape `notte functions create` expects.

# example flow
SESSION_ID=$(notte sessions start -o json | jq -r '.session_id')
notte page goto --session-id "$SESSION_ID" news.ycombinator.com
notte page scrape --session-id "$SESSION_ID" --instructions "Extract the top 10 stories from Hacker News. For each story return: rank, title, URL, points, author, number of comments" -o json
notte sessions workflow-code --session-id "$SESSION_ID"

# returns
from __future__ import annotations

from notte_sdk import NotteClient
from pydantic import BaseModel

class Story(BaseModel):
    rank: int | None = None
    title: str | None = None
    url: str | None = None
    points: int | None = None
    author: str | None = None
    number_of_comments: int | None = None


class Model(BaseModel):
    stories: list[Story] | None = None

client = NotteClient()

def run() -> Model:
    with client.Session() as session:
        _ = session.execute(type='goto', url='news.ycombinator.com')

        # directly parses the output using response_format and returns the Model
        return session.scrape(instructions='Extract the top 10 stories from Hacker News. For each story return: rank, title, URL, points, author, number of comments', scrape_links=True, scrape_images=False, response_format=Model)

run()

Cookie management:

# Get all cookies
notte sessions cookies --session-id <session-id>

# Set cookies from JSON file
notte sessions cookies-set --session-id <session-id> --file cookies.json

Page Actions

Simplified commands for page interactions:

Element Interactions:

# Click an element (use either the IDs from observe, or a selector)
notte page click --session-id <session-id> "B3"
notte page click --session-id <session-id> "#submit-button"
  --timeout     Element timeout in milliseconds (distinct from the global
                --timeout, which is the API request timeout in seconds)
  --enter       Press Enter after clicking

# Fill an input field
notte page fill --session-id <session-id> "I1" "hello world"
  --clear       Clear field before filling
  --enter       Press Enter after filling
  --vault-field Fill from the attached vault instead of using a literal value:
                email, username, password, or mfa

# Check/uncheck a checkbox
notte page check --session-id <session-id> "#my-checkbox"
  --value       true to check, false to uncheck (default: true)

# Select dropdown option
notte page select --session-id <session-id> "#dropdown-element" "Option 1"

# Download a file by clicking an element. The file lands in the REMOTE session,
# not on your machine - see "Files: upload and download" below.
notte page download --session-id <session-id> "L5"

# Fill a file input. --file names a file already uploaded to this session,
# NOT a path on your machine - see below.
notte page upload --session-id <session-id> "#file-input" --file report.pdf

Run JavaScript in the page:

• Escape single quotes if needed.
• console.log output is discarded - only the returned value comes back.
• Use a single expression, or a function that returns a value.
• The returned value is printed alone on stdout (objects and arrays as JSON, a JS null as null), with the status line on stderr - so it captures into a shell variable and pipes without post-processing. Use -o json when you want the whole execution result instead.
• A failing script exits non-zero and reports the actual JavaScript error, so set -e and || fallbacks behave.

# Single expression
notte page eval-js --session-id <session-id> 'document.title'

# Function with return value
notte page eval-js --session-id <session-id> '
() => {
  const els = document.querySelectorAll("a");
  return els.length;
}
'

# Capture the value, or pipe it - the value is all stdout carries
title=$(notte page eval-js --session-id <session-id> 'document.title')

notte page eval-js --session-id <session-id> \
  'JSON.stringify([...document.querySelectorAll("a")].map(a => a.href))' | jq length

Return JSON.stringify(...) whenever the answer is structured: it arrives as a JSON document, so jq does the filtering instead of another round trip through the page.

Navigation:

notte page goto --session-id <session-id> "https://example.com"
notte page new-tab --session-id <session-id> "https://example.com"
notte page back --session-id <session-id>
notte page forward --session-id <session-id>
notte page reload --session-id <session-id>

Scrolling:

notte page scroll-down --session-id <session-id> [amount]
notte page scroll-up --session-id <session-id> [amount]

Keyboard:

notte page press --session-id <session-id> "Enter"
notte page press --session-id <session-id> "Escape"
notte page press --session-id <session-id> "Tab"

Tab Management:

notte page switch-tab --session-id <session-id> 1
notte page close-tab --session-id <session-id>

Page State:

# Observe page state and available actions (takes no URL - `goto` first)
notte page observe --session-id <session-id>

# Save a screenshot as JPEG. With no argument it writes to
# <tmp>/notte-screenshot-<session-id>.jpg and prints the path.
notte page screenshot --session-id <session-id>
notte page screenshot --session-id <session-id> shot.jpg          # positional output path
notte page screenshot --session-id <session-id> --path shot.jpg   # same, as a flag

# Scrape content with instructions
notte page scrape --session-id <session-id> --instructions "Extract all links" [--only-main-content]

--only-main-content can reduce output size and token cost by filtering out navigation, sidebars, footers, and other page chrome. It can also reduce recall, especially on dynamic pages or layouts where important content is not classified as main content. When completeness matters, try scraping without --only-main-content first, then add it only if the full-page output is too noisy or expensive.

Utilities:

# Wait for specified duration
notte page wait --session-id <session-id> 1000

# Solve CAPTCHA - pass the challenge type, e.g. recaptcha_v2 or hcaptcha
notte page captcha-solve --session-id <session-id> "recaptcha_v2"

# Cloudflare WAF challenge pages and Turnstile use the cloudflare type
notte page captcha-solve --session-id <session-id> "cloudflare"

# Mark task complete
notte page complete --session-id <session-id> "Task finished successfully" [--success=true]

# Fill form with JSON data
notte page form-fill --session-id <session-id> --data '{"email": "test@example.com", "name": "John"}'

CAPTCHA solving is enabled automatically for a session unless it was started with --no-solve-captchas. If a Cloudflare WAF interstitial or Turnstile challenge is still visible, explicitly run captcha-solve with the cloudflare type before continuing with page actions.

Functions (Workflow Automation and API Endpoints)

Use Notte Functions to create callable, scheduled, or reusable browser automations. This is the path for turning a browser task or scrape into an endpoint, API, webhook, job, workflow, or service.

A Notte Function is the deployed endpoint form of a browser workflow: run(...) parameters become invocation variables, and its returned JSON-serializable value becomes the run result.

# List all functions (with optional pagination and filters)
notte functions list [--page N] [--page-size N] [--include-deleted]   # deleted are hidden by default

# Create a function from a workflow file
notte functions create --file workflow.py [--name "My Function"] [--description "..."] [--shared]

# Show function details (returns metadata + a download URL for the
# workflow file in `url`; it does not inline the source)
notte functions show --function-id <function-id>

# Download function code to a local Python file (latest version by default)
notte functions download current_function.py --function-id <function-id>
notte functions download previous_function.py --function-id <function-id> --version <version>

# Update function code
notte functions update --function-id <function-id> --file workflow.py

# Delete a function
notte functions delete --function-id <function-id>

# Run a function. This BLOCKS until the run finishes and returns
# `status` and `result` inline - there is no client-side polling.
notte functions run --function-id <function-id>
notte functions run --function-id <function-id> --var page=2                # repeatable; values arrive as strings
notte functions run --function-id <function-id> --vars '{"page": 2}'        # use JSON for real numbers/booleans

# Manage function environment secrets (read from os.environ inside run())
notte functions secrets list
notte functions secrets set NAME <value>
notte functions secrets get NAME
notte functions secrets delete NAME

# Invoke the deployed Function over HTTP from another service
curl -L -X POST "https://api.notte.cc/functions/{function_id}/runs/start" \
  -H "Authorization: Bearer $NOTTE_API_KEY" \
  -H "X-Notte-Api-Key: $NOTTE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "function_id": "{function_id}",
    "variables": {
      "url": "https://example.com",
      "max_items": 10
    }
  }'

# List runs for a function (with optional pagination and filters)
notte functions runs --function-id <function-id> [--page N] [--page-size N] [--running]   # full history; --running = in-flight only

# Stop a running function execution
notte functions run-stop --function-id <function-id> --run-id <run-id>

# Get run logs and results
notte functions run-metadata --function-id <function-id> --run-id <run-id>

# Schedule a function with cron expression
notte functions schedule --function-id <function-id> --cron "0 9 ? * * *"

# Remove a function schedule
notte functions unschedule --function-id <function-id>

# Fork a shared function to your account
notte functions fork --function-id <shared-function-id>

Skill rule: Always save the function_id returned by functions create (or obtain it from functions list) and pass it as --function-id to every command that targets a Function. Do not rely on the CLI's current-Function fallback.

Reading a run result. notte functions run --function-id <function-id> blocks server-side and returns status and result together. Judge the run on result, not status alone - a successful run reports status: "closed", and so does a run that raised inside run(), with the error text in result. result is the return value of run() serialized to JSON: a dict comes back as a real nested object, a str as a JSON string. A string containing Script execution failed or a Traceback is a failure.

The response also carries function_run_id, session_id, and workflow_run_id:

{"function_id": "...", "function_run_id": "...", "result": {"count": 1},
 "session_id": null, "status": "closed", "workflow_id": "...", "workflow_run_id": "..."}

Getting logs. functions run does not return logs. Take the function_run_id from its response and read the metadata:

RID=$(notte functions run --function-id "$FUNCTION_ID" -o json | jq -r '.function_run_id')
notte functions run-metadata --function-id "$FUNCTION_ID" --run-id "$RID" -o json | jq -r '.logs[]'

Note run-metadata's result is a Python repr (single-quoted, not valid JSON) rather than the clean object functions run gives you - use it for logs and history, and take the result from functions run.

notte functions runs --function-id <function-id> returns the full history by default; add --running to narrow to runs still executing.

Long-running Functions. Because the run is synchronous, it is bounded by the CLI's global --timeout (default 60 seconds). A Function that takes longer fails the command while the run continues server-side. Set a generous timeout on the first invocation: notte functions run --function-id <function-id> --timeout 600.

A command timeout is not a failed run - do not just re-run it. The client giving up does not cancel the run; it keeps executing and completes normally. Re-running therefore invokes the Function a second time, duplicating any form submission, purchase, or write. Find the existing run instead:

# still executing?
notte functions runs --function-id "$FUNCTION_ID" --running -o json | jq -c '.[] | {function_run_id, status}'
# once it is done, the newest entry in the full history carries the outcome:
notte functions runs --function-id "$FUNCTION_ID" -o json | jq -c '.[0]'

For reusable or repeated browser work, load and follow Function Management Reference before creating or updating a Function. Load Python SDK Interop only when editing exported workflow code or writing Function files by hand.

Account Management

Personas - Auto-generated identities with email:

# List personas (with optional pagination and filters)
notte personas list [--page N] [--page-size N] [--include-deleted]   # deleted are hidden by default

# Create a persona
notte personas create [--create-vault] [--create-phone-number]

# Show persona details
notte personas show --persona-id <persona-id>

# Delete a persona
notte personas delete --persona-id <persona-id>

# List emails received by persona
notte personas emails --persona-id <persona-id>

# List SMS messages received (requires a persona with a phone number - see below)
notte personas sms --persona-id <persona-id>

Phone numbers are a gated feature. notte personas create --create-phone-number will fail on a standard account - phone-number provisioning is unlocked per-account by the Notte team. Without it, the persona has an email inbox but no number, and notte personas sms has nothing to return.

Do not retry the command or work around it; it is an account entitlement, not a transient error. To request access, book a 15-minute call:

https://cal.com/pintoa/15mins

If the user needs SMS/phone verification and the feature is not unlocked, say so plainly, share that link, and fall back to an email-based flow (notte personas emails) if the target site supports one.

Vaults - Store your own credentials:

# List vaults (with optional pagination and filters)
notte vaults list [--page N] [--page-size N] [--include-deleted]   # deleted are hidden by default

# Create a vault
notte vaults create [--name "My Vault"]

# Update vault name
notte vaults update --vault-id <vault-id> --name "New Name"

# Delete a vault
notte vaults delete --vault-id <vault-id>

# Manage credentials
notte vaults credentials list --vault-id <vault-id>
notte vaults credentials add --vault-id <vault-id> --url "https://site.com" --password "pass" [--email "..."] [--username "..."] [--mfa-secret "..."]
notte vaults credentials get --vault-id <vault-id> --url "https://site.com"
notte vaults credentials delete --vault-id <vault-id> --url "https://site.com"

Files: upload and download

The browser runs remotely, so files do not move between it and your machine on their own. Every file is owned by a browser session. Within that session, --from filters files by how they arrived:

notte files upload --session-id <session-id> <local-path>             # local machine -> session
notte files list --session-id <session-id> --from uploads             # source=user_upload
notte files list --session-id <session-id> --from session             # source=session_download
notte files download --session-id <session-id> <file-id> [--path <local-path>]

Sending a local file into a web form takes two steps. notte page upload --session-id <session-id> --file resolves the name against files already uploaded to that same session, not your filesystem. Passing a local path that was never uploaded fails with Unable to get file: <path> for upload:

notte files upload --session-id <session-id> ./invoice.pdf                      # 1. into this session
notte page upload --session-id <session-id> "#file-input" --file invoice.pdf    # 2. into the page
notte page click --session-id <session-id> "#submit"

Getting a downloaded file onto your machine takes two steps as well - page download only moves it as far as the session:

notte page observe --session-id <session-id>                                    # required before using an element ID
notte page download --session-id <session-id> "L3"                              # -> the session store, still remote
notte files list --from session --session-id <session-id>                       # find its immutable file ID
notte files download --session-id <session-id> <file-id> --path ./report.csv

Notes:

• files upload, files list, and files download all require the owning session's --session-id.
• files download takes the immutable id returned by files list, not the display filename. --from is a filter for files list and is not accepted by files download.
• Without --path, a download uses the server-provided filename when available and otherwise falls back to the file ID.
• Using an element ID (L3, B1) without a prior notte page observe --session-id <session-id> in that session fails with No snapshot is available in the session. A CSS selector needs no observe.

Browser Profiles

Profiles are the persistent browser state (cookies, localStorage, sessionStorage) that --profile-id loads. Create one before you can reference it:

# Create a profile
notte profiles create

# List profiles
notte profiles list

# Show profile details
notte profiles show --profile-id <profile-id>

# Delete a profile
notte profiles delete --profile-id <profile-id>

# Read the cookies a profile holds
notte profiles cookies --profile-id <profile-id>

# Import cookies into a profile, replacing what is there
notte profiles cookies-set --profile-id <profile-id> --file cookies.json

notte profiles cookies-set takes either a bare array of cookies - what Playwright's storageState and the browser extensions export - or an object with a cookies key. Add --source-format chrome if they came from Chrome rather than Playwright, and --mode append to add to the profile's cookies instead of replacing them.

Typical use - log in once, persist the state, then reuse it without logging in again:

PROFILE_ID=$(notte profiles create -o json | jq -r '.profile_id')

# First run: log in and save the resulting state back to the profile
notte sessions start --profile-id "$PROFILE_ID" --profile-persist
# ... perform the login ...
notte sessions stop --session-id <session-id>

# Later runs: start already authenticated, without persisting new changes
notte sessions start --profile-id "$PROFILE_ID"

Web Search

notte search queries the Notte search API directly - no browser session required. Prefer it over spinning up a session when you need to find pages rather than interact with them.

notte search "latest llm releases"
notte search "what is anthropic" --depth deep
notte search "what is anthropic" --output-type sourcedAnswer

  --depth         standard (default), fast, or deep
  --output-type   searchResults (default), sourcedAnswer, or structured

Other Commands

notte usage      # Show API usage statistics
notte usage logs # List the API requests made with this workspace's credentials
notte health     # Check API health status
notte clear      # Clear legacy stored CLI resource pointers

Filters on list commands

Every list command takes a filter flag, but "active" means a different thing per resource. Read it as "live", then check what dead means:

Two rules follow:

• Do not widen artifact listings by reflex. The default on functions list, vaults list, personas list, and profiles list is correct - it hides deleted records. Widening surfaces tombstones, and acting on a deleted Function or vault id will fail confusingly. Only pass --include-deleted when the user is specifically asking what was deleted.
• Run listings are the exception: they already show everything, so an empty functions runs really does mean the Function has never run.

An empty session list means "nothing is running right now", not "nothing exists" - pass -a/--all to see finished ones.

Requires CLI v0.0.30 or newer. --include-deleted, -a/--all, and --running landed there, along with the change that made functions runs return history by default. Older CLIs expose a single --only-active on every command, whose meaning flips per resource; if notte version predates v0.0.30, upgrade rather than translating flags.

Global Options

Available on all commands:

--output, -o    Output format: text, json (default: text)
--timeout       API request timeout in seconds (default: 60)
--no-color      Disable color output
--verbose, -v   Verbose output
--yes, -y       Skip confirmation prompts

Environment Variables

Explicit Resource IDs

Always pass the corresponding resource-specific ID flag when this skill operates on a session, Function, vault, persona, or profile. Capture IDs from create/start responses or obtain them from the matching list command; never rely on an inferred default.

Examples

Basic Web Scraping

# Scrape with session
SESSION_ID=$(notte sessions start -o json | jq -r '.session_id')
notte page goto --session-id "$SESSION_ID" "https://news.ycombinator.com"
notte page scrape --session-id "$SESSION_ID" --instructions "Extract top 10 story titles"
notte sessions stop --session-id "$SESSION_ID"

# Multi-page scraping
SESSION_ID=$(notte sessions start -o json | jq -r '.session_id')
notte page goto --session-id "$SESSION_ID" "https://example.com/products"
notte page observe --session-id "$SESSION_ID"
notte page scrape --session-id "$SESSION_ID" --instructions "Extract product names and prices"
notte page click --session-id "$SESSION_ID" "L3"
notte page scrape --session-id "$SESSION_ID" --instructions "Extract product names and prices"
notte sessions stop --session-id "$SESSION_ID"

Form Automation

SESSION_ID=$(notte sessions start -o json | jq -r '.session_id')
notte page goto --session-id "$SESSION_ID" "https://example.com/signup"
notte page fill --session-id "$SESSION_ID" "#email-field" "user@example.com"
notte page fill --session-id "$SESSION_ID" "#password-field" "securepassword"
notte page click --session-id "$SESSION_ID" "#submit-button"
notte sessions stop --session-id "$SESSION_ID"

Authenticated Session with Vault

# Setup credentials once
notte vaults create --name "MyService"
notte vaults credentials add --vault-id <vault-id> \
  --url "https://myservice.com" \
  --email "me@example.com" \
  --password "$MYSERVICE_PASSWORD" \
  --mfa-secret "EXAMPLEMFASECRET"   # placeholder — replace with your real base32 TOTP seed

# Attach the vault to the session, then select credentials by field name.
# The CLI sends the corresponding placeholder for server-side substitution,
# so the script never contains the sentinel or the real secret.
SESSION_ID=$(notte sessions start --vault-id <vault-id> -o json | jq -r '.session_id')
notte page goto --session-id "$SESSION_ID" "https://myservice.com/login"
notte page fill --session-id "$SESSION_ID" "input[name='email']" --vault-field email
notte page fill --session-id "$SESSION_ID" "input[name='password']" --vault-field password
notte page fill --session-id "$SESSION_ID" "input[name='otp']" --vault-field mfa
notte sessions stop --session-id "$SESSION_ID"

Named vault fields. Pass one of these names to --vault-field; the CLI maps it to the placeholder that Notte replaces with the matching vault credential before the keystrokes hit the page. Do not write sentinel strings directly.

Scheduled Data Collection

# 1. Build the workflow interactively, then export the session that worked
SESSION_ID=$(notte sessions start -o json | jq -r '.session_id')
notte page goto --session-id "$SESSION_ID" "https://news.ycombinator.com"
notte page scrape --session-id "$SESSION_ID" --instructions "Extract the top 10 stories with title, url, points"
notte sessions workflow-code --session-id "$SESSION_ID" > collect_data.py
notte sessions stop --session-id "$SESSION_ID"

# 2. Edit collect_data.py to add a run(...) entry point whose parameters are the
#    values that change between runs. See references/function-management.md.

# 3. Create the Function and capture its ID
FUNCTION_ID=$(notte functions create \
  --file collect_data.py \
  --name "Daily Data Collection" \
  -o json | jq -r '.function_id')

# 4. Verify it actually works before scheduling it
notte functions run --function-id "$FUNCTION_ID" -o json | jq '{status, result}'

# 5. Schedule to run every day at 9 AM
notte functions schedule --function-id "$FUNCTION_ID" --cron "0 9 ? * * *"

# 6. Check run history
notte functions runs --function-id "$FUNCTION_ID"

Tips & Troubleshooting

Handling Inconsistent observe Output

The observe command may sometimes return stale or partial DOM state, especially with dynamic content, modals, or single-page applications. If the output seems wrong:

1. Use screenshots to verify: notte page screenshot --session-id <session-id> always shows the current visual state
2. Fall back to Playwright selectors: Instead of observe IDs, use standard selectors like #id, .class, or button:has-text('Submit')
3. Add a brief wait: notte page wait --session-id <session-id> 500 before observing can help with dynamic content

Selector Syntax

Both element IDs from observe and Playwright selectors are supported:

# Using element IDs from observe output
notte page click --session-id <session-id> "B3"
notte page fill --session-id <session-id> "I1" "text"

# Using Playwright selectors (recommended when observe IDs don't work)
notte page click --session-id <session-id> "#submit-button"
notte page click --session-id <session-id> ".btn-primary"
notte page click --session-id <session-id> "button:has-text('Submit')"
notte page click --session-id <session-id> "[data-testid='login']"
notte page fill --session-id <session-id> "input[name='email']" "user@example.com"

Handling multiple matches - Use >> nth=0 to select the first match:

# When multiple elements match, select by index
notte page click --session-id <session-id> "button:has-text('OK') >> nth=0"
notte page click --session-id <session-id> ".submit-btn >> nth=0"

Working with Modals and Dialogs

Modals and popups can interfere with page interactions. Tips:

• Close modals with Escape: notte page press --session-id <session-id> "Escape" reliably dismisses most dialogs and modals
• Wait after modal actions: Add notte page wait --session-id <session-id> 500 after closing a modal before the next action
• Check for overlays: If clicks aren't working, a modal or overlay might be blocking - use screenshot to verify

# Common pattern for handling unexpected modals
notte page press --session-id <session-id> "Escape"
notte page wait --session-id <session-id> 500
notte page click --session-id <session-id> "#target-element"

Viewing Headless Sessions

All sessions run headlessly, which doesn't mean you can't see the browser:

• ViewerUrl: When you start a session, the output includes a ViewerUrl - open it in your browser to watch the session live
• Viewer command: notte sessions viewer --session-id <session-id> opens the viewer directly

# Start a session and get viewer URL
notte sessions start -o json | jq -r '.viewer_url'

# Or open the viewer for that session
notte sessions viewer --session-id <session-id>

Bot Detection / Stealth

If you're getting blocked or seeing CAPTCHAs, try enabling our residential proxies:

notte sessions stop --session-id <session-id>
notte sessions start --proxy

Note: Session configuration cannot be changed mid-session. Stop the explicit session ID and start a new session when parameters must change.

Security Notes

Two risk classes are inherent to "browser automation driven by an agent." The skill can't eliminate them; the mitigations below are what callers should apply.

Credential handling

notte vaults credentials add takes --password and --mfa-secret as CLI arguments, and there is no stdin or file-based alternative. Anything you pass there lands in argv, where it is visible to ps and to process snapshots for the lifetime of the call.

Be precise about what the env-var form does and does not buy you:

• --password "$MY_PASSWORD" does keep the literal secret out of your shell history and out of any file you commit.
• It does not keep it out of argv — the shell expands the variable before exec, so ps sees the plaintext either way. This is a real limitation of the CLI, not something the caller can work around.

Given that, the practical rule is to minimize how often the secret crosses argv at all:

• DO add each credential to a vault once, from a machine and shell you control, with the value expanded from an environment variable or a .env file you own.
• DO rely on the vault plus --vault-field from then on. The CLI references the credential by name, so neither the sentinel nor the real secret appears in the command.
• DO use notte functions secrets set for values a Function reads from os.environ, rather than baking them into the workflow file or passing them as run variables.
• DON'T type real credentials inline. The values in this skill ($MYSERVICE_PASSWORD, EXAMPLEMFASECRET, etc.) are placeholders.
• DON'T run credential-adding commands on a shared or multi-tenant host, where another user can read ps output during the call.

Untrusted page content

notte page scrape --session-id <session-id> ingests content from arbitrary URLs. That content reaches the calling agent's context as tool output and can con

…(truncated)