Notte Web Automation
A Python framework and hosted API for browser-based AI automation and structured web extraction.
Per-dimension scores and reasoning
Evidence: README describes vault and persona features, implying credential management, but no implementation details or least-privilege explanations. User confirmation mechanism not seen. Data flow transparency limited, only mentions file storage and cookie management. Sensitive data handling has vault and persona concepts but not in-depth. Dependency security has pyproject.toml listing dependencies, but no vulnerability scanning or lock file. External effects evident (browser automation, proxies, CAPTCHA solving), but side effects not discussed. Rollback mechanism not seen. Source attribution has author and copyright, but publisher unverified. Deductions: lack of concrete implementation evidence, permissions and user confirmation not addressed.
Evidence: README and docs tests show internal consistency, e.g., parameter sync tests. Dependency availability: dependency list exists, but no lock file or version ranges. Failure messages: docs mention AgentFallback for handling failures, but no specific error message format. Deductions: dependency locking and error message details insufficient.
Evidence: README targets developers, provides multiple scenarios (agents, scraping, hybrid workflows). Capability boundaries: describes feature scope, but no explicit limitations. Trigger precision: tasks described in natural language, but no precise trigger conditions. Environment fit: supports local and cloud modes, but no system requirements. Deductions: trigger precision and boundary definitions not precise enough.
Evidence: Information architecture clear, with README, docs, tests. Install notes provide pip command. Naming stability: version number exists, but no changelog. Examples and FAQ: many examples, but FAQ not seen. Known limitations: not explicitly listed. License: SSPL-1.0 clear. Versioning: version number, but no changelog. Maintenance responsibility: author and contact, but no maintenance policy. Deductions: missing changelog, FAQ, and known limitations.
Evidence: Output usability: provides structured output and scraping. Marginal value: emphasizes cost reduction and reliability. Cost-benefit: claims 50%+ cost reduction, but no detailed data. Deductions: cost-benefit claims lack concrete evidence.
Evidence: Claim traceability: benchmarks link to external repo, but no raw data. Cross-source: external links exist, but not independently verified. Fact-inference separation: README distinguishes features and benchmarks, but inferences not explicitly labeled. Deductions: benchmark data not provided, inferences not clearly marked.
- Publisher unverified, identity unknown.
- Dependencies not locked, supply chain risk.
- Sensitive data handling (vault/persona) implementation details not disclosed.
- Benchmark data not provided, claims should be treated with caution.
- SSPL license may affect commercial use.
What does this agent do, and when should you use it?
Notte is a Python framework and API service for building, deploying, and scaling AI automations that interact with websites. Its open-source path uses `notte.Session` and `notte.Agent` with a local browser session and the user's own LLM API keys. Its hosted path uses `notte_sdk.NotteClient` to create sessions and agents, and requires a Notte API key. The documented workflow combines Playwright-compatible deterministic actions with natural-language agent steps and can return Pydantic-defined structured output. The README also documents hosted session features including Vaults, Personas, file storage, cookies, CDP connections, proxies, and CAPTCHA solving.
In local mode, you install notte and Chromium through Patchright, open a notte.Session, and call notte.Agent(...).run(task=...) for a natural-language browser task. In hosted mode, NotteClient creates the session and agent; the session can call session.execute(type="goto"|"fill"|"click", ...), session.observe(), and session.scrape(instructions=...). Agent.run accepts a Pydantic response_format and exposes the returned result through response.answer. client.scrape fetches and extracts a URL directly, while FileStorage uploads inputs and retrieves files downloaded during an agent session.
- A Python developer running browser tasks locally with their own LLM API keys for navigation, form actions, or image search.
- A data-extraction engineer collecting article or Hacker News fields into a Pydantic schema with titles, URLs, authors, scores, and content.
- An automation team scripting stable navigation and form filling with
session.execute, then using an Agent only for steps requiring web-page reasoning. - A team needing hosted browser sessions with proxies, CAPTCHA handling, cookies, or a connection to an external CDP-compatible browser.
- A user automating a login workflow by adding site credentials to a
Vaultfor use by an Agent. - A workflow that must upload a PDF to a website and retrieve files downloaded by the agent through
FileStorage.
What are this agent's strengths and limitations?
- It explicitly combines deterministic
session.executebrowser primitives with agent reasoning, so stable portions can remain scripted. - Pydantic-backed
response_formatprovides a documented way to constrain web-extraction results to a caller-defined structure. - The hosted session interface documents proxies, automatic CAPTCHA solving, Vaults, Personas, file storage, cookies, and CDP connectivity.
AgentFallbackprovides a documented recovery pattern when a deterministic browser action fails.
- Local use requires Python 3.11+, Patchright, Chromium, and LLM API keys supplied by the adopter.
- Hosted capabilities require a Notte Console API key; the README supplies no standalone
notte_sdkinstallation command or pricing details. - The supplied repository metadata lists the license as NOASSERTION while the README says SSPL-1.0, so the effective license should be verified before adoption.
- Its benchmark ranking is reported from the linked
open-operator-evals; it does not establish results for a specific site, model, or workload.
How do you install or deploy this agent?
Local mode requires Python 3.11+. Install the package and Chromium:
pip install notte
patchright install --with-deps chromiumA local agent also needs your own LLM API keys. For the hosted SDK path, create NOTTE_API_KEY in the Notte Console; the README shows from notte_sdk import NotteClient but does not provide a separate installation command for notte_sdk.
How do you use this agent?
First local invocation:
import notte
with notte.Session(headless=False) as session:
agent = notte.Agent(session=session, reasoning_model='gemini/gemini-2.5-flash', max_steps=30)
response = agent.run(task='doom scroll cat memes on google images')For hosted execution, create NotteClient(api_key=os.getenv('NOTTE_API_KEY')), create client.Session(...), then create client.Agent and call the same run method.
How does this agent compare with similar options?
The README's benchmark table compares Notte with Browser-Use and Convergence (proxy-lite). It reports 86.2% Agent Self-Report, 79.0% LLM Evaluation, 47 seconds per task, and 96.6% Task Reliability for Notte; these are reported evaluation figures, not guarantees for other environments.
FAQ
Can it run entirely locally?
notte.Session and notte.Agent; you install Patchright and Chromium and provide your own LLM API keys.When is a Notte API key required?
NOTTE_API_KEY created in the Notte Console is required for the hosted NotteClient path and its documented hosted session features.Can it return validated structured data?
response_format to Agent.run or client.scrape to request output in that model's structure.What happens if a scripted action fails?
AgentFallback(session, "..."), which can invoke an agent recovery task when a deterministic session.execute operation fails.Can it use an existing browser provider?
client.Session(cdp_url=...) for an external CDP-compatible browser session.