Notte review, pricing and verdict

Pick Notte when an agent needs a real browser with logins, proxies and CAPTCHA solving, and you want the recorded flow deployable as a scheduled Function afterwards. Skip it if a page-to-Markdown API already covers the job, or if you need your own LLM keys on the cheapest paid plan. Four surfaces (API, CLI, MCP, SDKs) share one account.

Notte is cloud browser infrastructure for AI agents from Notte Labs, a Y Combinator company: an API of 15 session, page, agent and scrape endpoints, a notte CLI with vaults, personas, replays and deployable Functions, and two hosted Model Context Protocol servers. Agents observe a page as numbered elements, act by id, scrape to a schema, or delegate whole tasks to a Notte browser agent.

Maker: Notte Labs · Protocol: MCP · Auth: api key

Compatible agents: Claude Code and Claude Desktop (skill file + MCP), Cursor, Windsurf and other MCP clients, Vercel AI SDK agents (documented integration), Any LLM for the browser agent (model-agnostic, bring your own keys on Startup and above), Orthogonal gateway (orth run)

Required runtime: notte CLI via Homebrew (brew tap nottelabs/notte-cli) or Go (go install github.com/nottelabs/notte-cli/cmd/notte@latest), npx for the one-line skill install, Any HTTP client for the REST API; Python or TypeScript for the SDKs, An MCP client for the two hosted servers

About Notte

Notte is browser infrastructure built for AI agents by Notte Labs, a Y Combinator company. It is a skill rather than an end-user tool because every part of it is meant to be driven by code or by an assistant: an agent starts a cloud browser session, observes the page as a list of numbered actions, clicks and fills by those IDs or by selector, scrapes structured data with an instruction or a schema, and stops the session; or it hands a whole task to a Notte browser agent and polls for the result. The vendor states on its homepage that more than 20,000 developers and 1,000 organisations use it. The product lives at notte.cc (the unrelated notte.io domain is a nightlife waitlist page).

There are four surfaces over one account. The REST API is the base layer, with the same paths the Orthogonal gateway resells per call: session start, status, stop, cookies and network logs; page observe, execute, scrape and screenshot; agent start, status and stop; and two browserless scrapers (a URL scrape and scrape_from_html). The notte CLI (Homebrew or Go, version 0.0.41 or newer per the vendor's skill file) wraps all of it and adds vaults for credentials, personas for synthetic identities with inboxes and phone numbers, replays and live viewers, tunnels through your own machine, and the export of a recorded session as Python workflow code. Two hosted MCP servers come with the plugin: api.notte.cc/mcp exposes the browser API as tools, and anything.notte.cc/mcp is a marketplace of ready-made Notte Functions with search, spec, run and a natural-language build tool that deploys a new Function in a few minutes. Functions are the deployment form: AWS-Lambda-style runtimes colocated with the browsers, callable by API, webhook or cron.

Sessions default to chromium with CAPTCHA solving on, a three-minute idle timeout and a quarter-hour maximum lifetime, and can take residential proxies by country, a browser profile that persists login state, a custom viewport and user agent, or a CDP URL to a browser you already run. Agents accept a task, an optional starting URL, a step cap of up to 50 and a vision toggle; the vendor is model-agnostic and bills LLM tokens at the provider's price. The nearest HokAI neighbours are Kernel, the other cloud-browser skill in the directory and the subject of the vendor's own comparison post, Olostep for scraping and crawling without a live browser, Riveter for enrichment runs that do their own browsing server-side, Jina Search Foundation API for reading pages as Markdown, and SearchApi when the job is a results page rather than a site.

Pricing is credits plus operational limits. Browser session time is listed at $0 an hour, Functions at five cents an hour of runtime, residential proxies by the gigabyte, and LLM tokens at cost with no markup when Notte's keys are used; the plans differ mainly in concurrency, session duration, vault and persona counts, and whether you can bring your own keys and proxies. CAPTCHA solving and stealth are included on every plan. A trust centre, SSO, SLAs, HIPAA terms and on-premise deployment are enterprise items.

The skill file the vendor publishes for assistants is unusually operational: it insists on observing the live page before writing selectors, on stopping sessions when done, and on checking the Functions marketplace before building a new automation. If you are deciding between a hosted browser, a scraping API and a research agent for your stack, Smart Match will ask the questions that separate them.

Key Features

• Observe-then-act page model: observe returns the page as numbered elements (B3, I1) so an agent clicks and fills by id instead of guessing selectors.
• Browser agents on any model: Hand a task to a Notte agent with a step cap of up to 50; the vendor reports a success rate above 90% on its homepage and bills tokens at provider price.
• Functions: deploy a recorded flow: Export a session as Python workflow code and deploy it as a callable, scheduled or webhook-triggered Function colocated with the browsers.
• Two hosted MCP servers: One hosted server turns the browser API into tools; the other, anything.notte.cc, searches, specs, runs and builds Functions from a marketplace.
• Vaults and personas: Credentials are filled from a vault without reaching the model, and personas provide synthetic identities with email and phone for sign-ups.
• Stealth and CAPTCHA solving included: Every plan includes anti-bot evasion and automatic solving, with explicit captcha-solve for reCAPTCHA, hCaptcha and Cloudflare challenges.
• Replays, live view and HAR logs: Each session can be watched live, replayed as video and exported as network logs for debugging.

Use Cases

• Checkout or form flow an agent cannot do headlessly: Start a session with a persisted profile and a vault, observe the page, click and fill by the returned IDs, solve a Turnstile with captcha-solve, and stop the session in a trap so it never leaks.
• Recorded workflow turned into a scheduled Function: Drive a site once with the CLI, export the steps with sessions workflow-code, deploy the Python file with functions create, and run it on a cron or by webhook with variables.
• One-shot task for a browser agent: POST an agent start with the task, a starting URL and max_steps, poll the agent status, and read the structured result without writing selectors.
• Structured scrape behind a login: Use page scrape with a JSON Schema response_format and only_main_content after navigating with a profile that already holds the session cookies.

Install

npx skills add nottelabs/notte-skills --skill notte-browser -y -g

Requirements

• A Notte account and API key from console.notte.cc/apikeys, or notte auth login for the interactive CLI flow (NOTTE_API_KEY for CI)
• notte CLI 0.0.41 or newer for the commands in the vendor's skill file; brew tap nottelabs/notte-cli or go install
• Credits on the account: Free grants a one-time balance, paid plans refresh monthly
• For your own LLM keys or proxies, the Startup plan or above

Actions

Start Session

Launches a cloud browser with the chosen engine, proxies, CAPTCHA solving, timeouts, viewport and user agent, and returns a session id.

SESSION_ID=$(notte sessions start --browser-type chromium --proxy --proxy-country sg \
  --idle-timeout-minutes 5 --max-duration-minutes 30 -o json | jq -r '.session_id')
trap 'notte sessions stop --session-id "$SESSION_ID" --yes' EXIT

• headless (boolean): Run headless.
• browser_type (string): chromium, chrome or firefox.
• proxies (boolean): Enable proxy rotation (CLI: --proxy, --proxy-country, or your own server).
• solve_captchas (boolean): Automatic CAPTCHA solving; on by default in the CLI.
• idle_timeout_minutes (number): Minutes idle before the session closes.
• max_duration_minutes (number): Hard lifetime of the session.
• viewport_width (number): Viewport width in pixels.
• viewport_height (number): Viewport height in pixels.
• user_agent (string): Custom User-Agent string.

Get Session

Returns a session's status and details.

notte sessions status --session-id "$SID" -o json

• session_id (string) — required: The session to inspect (path).

Stop Session

Stops the browser and cleans up the session.

notte sessions stop --session-id sess_7d1f --yes

• session_id (string) — required: Session to stop (path).

Observe Page

Returns the current page state as a numbered list of available actions (links, inputs, buttons) for the agent to pick from.

notte page goto --session-id "$SID" https://docs.notte.cc/
notte page observe --session-id "$SID" | head -40

• session_id (string) — required: Session whose page is observed (path).
• max_nb_actions (number): Most actions to return.
• min_nb_actions (number): Fewest actions to return.
• instruction (string): Filter the action list by intent.

Execute Page Action

Performs one action in the page by observed element id or selector: navigation, clicks, typing, scrolling, selects, hovers, waits or a screenshot.

S=sess_7d1f
notte page click --session-id $S B3
notte page fill --session-id $S I1 "hello world"
notte page press --session-id $S Enter

• session_id (string) — required: Target session (path).
• type (string) — required: goto, click, type, scroll, select, hover, wait or screenshot.
• url (string): Destination for goto.
• ref (string): Element reference from observe, or a selector, for click, type and select.
• text (string): Text to type.
• value (string): Option for select.
• direction (string): up or down for scroll.
• amount (number): Scroll distance in pixels.
• timeout (number): Wait time in milliseconds.

Scrape Page

Extracts content from the page open in the session, as text or as structured data matching a schema, with optional instructions and selector scoping.

notte page goto --session-id sess_7d1f news.ycombinator.com
notte page scrape --session-id sess_7d1f --only-main-content \n  --instructions "Extract the top 10 stories: rank, title, URL, points"

• session_id (string) — required: Session holding the page to scrape (path).
• selector (string): Playwright selector that scopes the scrape.
• scrape_links (boolean): Include links.
• scrape_images (boolean): Include images.
• only_main_content (boolean): Drop navigation and footer.
• response_format (object): Pydantic model or JSON Schema for structured output.
• instructions (string): Extra extraction instructions.

Take Screenshot

Captures the current page, optionally full-page, as a JPEG.

notte page screenshot --session-id sess_7d1f --path shot.jpg

• session_id (string) — required: Session to capture (path).
• full_page (boolean): Capture the whole page rather than the viewport.

Get Session Cookies

Returns all cookies held by the browser session.

notte sessions cookies --session-id "$SID" > cookies.json

• session_id (string) — required: Session to read (path).

Set Session Cookies

Loads cookies into the session, for example a saved login.

notte sessions cookies-set --session-id sess_7d1f --file login-cookies.json

• session_id (string) — required: Session to write to (path).
• cookies (array) — required: Array of cookie objects.

Get Network Logs

Returns the session's request and response log, downloadable as HAR.

notte sessions network --session-id "$SID" --urls-only

• session_id (string) — required: Session whose traffic is listed (path).

Start Agent

Runs a Notte browser agent autonomously on a task inside a session, with a step cap and optional vision.

curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' -H 'Content-Type: application/json' \
  -d '{"api":"notte","path":"/agents/start","body":{"task":"Find the cheapest return flight SIN to HKG next Friday and report the airline and fare","session_id":"'"$SESSION_ID"'","url":"https://www.google.com/travel/flights","max_steps":30}}'

• task (string) — required: What the agent should accomplish.
• session_id (string) — required: Session the agent drives.
• url (string): Starting URL.
• max_steps (number): Step cap, 1 to 50.
• use_vision (boolean): Use a vision model alongside the DOM.

Get Agent Status

Returns an agent run's execution status and, when finished, its result.

const res = await orth.run({ api: "notte", path: "/agents/{agent_id}", query: { agent_id: "agt_9f2c" } });
console.log(res.data.status, res.data.answer);

• agent_id (string) — required: The agent run (path).

Stop Agent

Halts a running agent.

curl --request POST --url https://api.orthogonal.com/v1/run --header "Authorization: Bearer $ORTHOGONAL_API_KEY" \n  --data '{"method":"DELETE","query":{"agent_id":"agt_c41e"},"path":"/agents/{agent_id}/stop","api":"notte"}'

• agent_id (string) — required: The agent run to stop (path).

Scrape Webpage

Fetches and scrapes a URL in one call, without an existing session, optionally into a structured schema.

import os, requests

r = requests.post(
    "https://api.orthogonal.com/v1/run",
    headers={"Authorization": f"Bearer {os.environ['ORTHOGONAL_API_KEY']}"},
    json={"path": "/scrape", "api": "notte", "body": {
        "url": "https://notte.cc/pricing",
        "schema": {"type": "object", "properties": {"plans": {"type": "array", "items": {"type": "string"}}}},
    }},
)
print(r.json()["data"])

• url (string) — required: Page to fetch and scrape.
• schema (object): Structured extraction schema.

Scrape from HTML

Extracts structured content from raw HTML you already hold, with no browser involved.

const parsed = await orth.run({
  path: "/scrape_from_html",
  api: "notte",
  body: { frames: [{ html: "<html><body><h1>Invoice 4471</h1><p>Total: SGD 120.00</p></body></html>" }] },
});

• frames (array) — required: HTML frames to parse.

How to Invoke

REST API (the 15 session, page, agent and scrape endpoints, also resold per call through the Orthogonal Run API with api: notte); the notte CLI (notte sessions, notte page, notte agents, notte functions, notte vaults, notte personas); the hosted MCP servers https://api.notte.cc/mcp (browser API as tools) and https://anything.notte.cc/mcp (Functions marketplace: search, spec, run, build); Python and TypeScript SDKs.

Pricing

Credits plus operational limits (notte.cc/pricing, read 11 October 2026). Free: $0, a one-time $10 credit grant that does not expire, 5 concurrent browsers, quarter-hour sessions. Developer: $20 a month with $20 of monthly credits, 25 concurrent browsers and agents, 120-minute sessions. Startup: $100 a month with $100 of credits, 100 concurrent, 300-minute sessions, bring your own LLM keys and proxies. Enterprise: custom credits, SSO, SLAs, HIPAA, on-premise. Usage rates: browser sessions $0 an hour, Functions $0.05 an hour, residential proxies $10 a GB, LLM tokens at provider price with no markup. Monthly credits expire each cycle; manual top-ups do not. The Orthogonal gateway resells the same endpoints per call at its own prices.

Strengths

• Browser time itself is listed at $0 an hour, so the metered costs are proxies, Functions runtime and your LLM tokens.
• The vendor's own skill file for assistants is published and versioned (CLI 0.0.41 or newer), which keeps agent instructions in step with the product.
• Persisted profiles, vaults and personas cover the login and identity problems that stop most headless scrapers.

Weaknesses

• Credits on the monthly plans expire each cycle, so light users pay for unused capacity unless they stay on Free with top-ups.
• Bring-your-own LLM keys and proxies need the Startup plan, so Developer-plan users run on Notte-managed keys only.
• The agent surface is reachable through the gateway and the API, but the CLI skill file documents sessions, pages and Functions far more thoroughly than agents.

View the official Notte skill page