Owl Browser: the browser for AI agents and automation at scale

Owl Browser is a Chromium-based engine, hosted for you by Olib AI or self-hosted on Enterprise. Drive it over REST, the Node and Python SDKs, or MCP. Agents read each page as compact OwlMark text with clickable handles, so they act on the page without parsing screenshots or raw HTML.

The trial is 14 days on shared hosting. Starter and Business run on a dedicated AWS instance in the region you choose; Enterprise runs the Docker image on your own servers.

REST tools
187
REST tools
isolated contexts per instance
256
isolated contexts per instance
MCP tools, 4 profiles
21–82
MCP tools, 4 profiles
Node and Python SDKs
2.3.0
Node and Python SDKs
engine
Chromium 156
engine

Explore the panel: hover, tap or tab through the numbered parts.Tap a numbered part to see what it does.

  1. Engine status – Shows whether the browser engine is up: Ready, Starting, Offline or License required. The refresh button checks again.
  2. Browser context – The isolated browser session you are driving, shown by its ctx_ id. Switch between open contexts, close this one, or open a new one with +.
  3. Address bar – Back, forward, reload and a web address for the selected context. Enter a URL and that context navigates to it.
  4. Find a tool – Describe what you want to do in plain words. It searches the tools and opens the best match with the matching parameters highlighted.
  5. Resources – Connect via MCP (endpoint and OAuth for AI agents), a guide to running flows from the SDK, and downloads of the OpenAPI spec and the Agent Skills reference.
  6. Theme – Switches the panel between System, Light and Dark.
  7. Tools – Run any single tool by hand: pick it, fill in its parameters and execute it against the live context.
  8. Flow designer – Chain steps such as Navigate, Click, Type and Extract Text, run them here with per-step status and timing, and export the flow as JSON or a Node.js or Python script.
  9. Tests – Runs the IPC protocol test suite against the engine (smoke, full, benchmark, stress, leak check or parallel) and keeps the reports.
  10. Tool list – Every tool the panel offers, grouped by category with a count on each. Search by name, and star the ones you use to pin them under Favorites.
  11. Live view – The selected context, streamed live with its page title and viewport size. Click, type and scroll here and the input goes to the real page.
  12. Results – Every run, newest first, with its status, a preview, time and duration. Expand one for the full result, or copy it as runnable code.
  13. Selected tool – The tool’s category, its name, the API id you call it by (browser_navigate) and what it does.
  14. Code tab – The same request Execute sends, as code you can run from your own machine: Node.js, Python, cURL or JavaScript.
  15. Parameters – Each parameter with its API name, a required mark and a short explanation. Context ID fills in from the context selected in the top bar.
  16. Execute – Runs the tool against the selected context. ⌘ Enter (Ctrl Enter on Windows and Linux) runs it from anywhere in the form.
The control panel served by every container (Owl Browser 1.4.2), redrawn from its source. The live view is a real screenshot taken by Owl of books.toscrape.com.

What is Owl Browser?

In short, Owl Browser is a browser engine for AI agents and large-scale automation, built from Chromium source. Olib AI hosts it for you, or you self-host it on Enterprise; you open isolated browser sessions through an API and control them from scripts, test suites or AI agents.

It is built for two kinds of work: automation that has to run many separate sessions at once (scraping, QA, account operations), and LLM agents that need to read a page and act on it in as few tokens as possible.

Deployment
Hosted for you by Olib AI: shared hosting on Developer Trial and Developer, or one dedicated 32 GB or 64 GB AWS instance in the region you choose on Starter and Business. On Enterprise you self-host one Docker image (linux/amd64) where nginx on port 80 serves the control panel and proxies the API.
Interfaces
REST (POST /execute/<tool>, 187 tools), WebSocket, Node and Python SDKs 2.3.0, and a native MCP server at /mcp.
Scale
Up to 256 isolated browser contexts per instance (documented limit; plan limits on the pricing page), each with its own cookies, storage, proxy and fingerprint. The HTTP server talks to the browser over a pool of 64 parallel IPC sockets.
Agent interface
browser_observe returns the page as OwlMark text with short handles (b3, l5) that browser_click and browser_type accept. MCP profiles: agent (21), automation (43), webdev (37), full (82).
Fingerprints
1,400 device profiles (100 hardware and OS bases across Chrome 143–156), implemented in C++ inside Chromium 156: 27 override modules and 66 source patches.
License
Commercial, by Olib AI. Monthly plans from $9.99, and a trial at $0.99 for 14 days; Enterprise, the self-hosted plan, includes registry access. See pricing.

An agent reads the page as text, not pixels

browser_observe turns the rendered page into OwlMark: headings, text, repeated items folded into templates, and a short handle for every link, button and field. The agent clicks the handle; it never has to locate anything on a screenshot.

https://books.toscrape.com/
Books to Scrape home page as rendered by Owl Browser: the All products heading, a category sidebar, a demo-site warning
What a person sees: Owl's own screenshot (browser_screenshot), cropped.

The response also carries 99 handles. The two for the first book:

browser_observe → handles
[
  {
    "token": "l116",
    "role": "link",
    "name": "A Light in the ..."
  },
  {
    "token": "b119",
    "role": "button",
    "name": "Add to basket"
  }
]
browser_observe → render (OwlMark)
# All products | Books to Scrape - Sandbox · books.toscrape.com · scroll 0/2569
control "We love being scraped!" [#x2 ~inferred]
  link "Books to Scrape" [#l3]
- link "Home" [#l5]
- text "/"
- text "All products"
region "Sidebar (collapsed) 51 items" [#R1]
## All products
[form #F1]
  1000
   results - showing
  1
   to
  20
  .
Warning!
 This is a demo website for web scraping purposes. Prices and ratings here were randomly assigned and have no real meaning.
  template T2 = listitem { article }
  T2 x12:
    - name="A Light in the AtticA Light in the ...£51.77  In stockAdd to basket" link "A Light in the ..." [#l116] button "Add to basket" [#b119]
    - name="Tipping the VelvetTipping the Velvet£53.74  In stockAdd to basket" link "Tipping the Velvet" [#l128] button "Add to basket" [#b131]
    - name="SoumissionSoumission£50.10  In stockAdd to basket" link "Soumission" [#l140] button "Add to basket" [#b143]
    - name="Sharp ObjectsSharp Objects£47.82  In stockAdd to basket" link "Sharp Objects" [#l152] button "Add to basket" [#b155]
    - name="Sapiens: A Brief History of Humankind — £54.23" link "Sapiens: A Brief History ..." [#l164] button "Add to basket" [#b167]
What the agent reads: the first 24 of 46 lines of the same page, verbatim except that the page's icon-font glyphs (star ratings, stock checks) were removed for display. The twelve product cards share one template (T2): one line each, with its link and button handles.

Measured size of the same page

Size of what an agent receives, per page
PageOwlMark renderFull observe responsePage HTML
books.toscrape.com~1,500 tokens
4,413 chars
~4,051 tokens
99 handles
~9,105 tokens
51,295 chars
news.ycombinator.com~1,813 tokens
5,230 chars
~4,304 tokens
112 handles
~12,415 tokens
33,999 chars

Measured 2026-11-17 on Owl Browser 1.4.1, 1920×957 viewport. Tokens are estimated with Owl's own token estimator; exact counts vary by model tokenizer. The full observe response adds the handle table and page metadata to the render.

The agent loop

  1. 1
    browser_create_context

    Open an isolated session. MCP clients get the agent render by default; REST and SDK callers pass render_mode "agent" or "both".

  2. 2
    browser_navigate

    Load the page, optionally waiting for load or network idle.

  3. 3
    browser_observe

    Read the page as OwlMark text plus a handle table of everything clickable or typeable.

  4. 4
    browser_click / browser_type

    Act with selector set to a handle such as b119, then observe again to see the result.

Over MCP the same loop needs no code: the default agent profile exposes 21 tools built around it. browser_observe reference

Flows

Build a browser automation without writing code

In the control panel you add steps by name (Navigate, Click, Type, Extract Text), repeat them for each item in a list, and branch with If / Then / Else. Press Run and every step shows whether it passed, how long it took and, when it fails, why.

For developers: the same flow exports as a JSON file or as a Node.js or Python script that runs it with the SDK's FlowExecutor. How flows work

Check book pricesRecorded run · replay

Steps 3

  1. Navigate, step 1

    Open the shop

    https://books.toscrape.com/

    ×2 attempts30000ms timeout
  2. Evaluate JavaScript, step 2

    List the first 3 books

    [...document.querySelectorAll('article.product_pod')].slice(0, 3).map(a => ({ title: a.querySelector('h3 a').title, url: a.querySelector('h3 a').href, price: Number(a.querySelector('.price_color').textContent.replace(/[^0-9.]/g, '')) }))

    expects: has 3 itemsbooks (saved as a variable)
  3. Repeat for Each Item, step 3

    Check each book

    For each item in ${vars.books} · current item ${vars.book}, position ${vars.index}

    For each item

    1. If Condition, step 3 › each 1

      Is it under £52?

      If Previous result.price Less Than 52

      Then

      1. Navigate, step 3 › each 1 › then 1

        Open the book's page

        ${vars.book.url}

        ×2 attempts30000ms timeout
      2. Extract Text, step 3 › each 1 › then 2

        Check it is in stock

        .product_main .availability

        expects: contains "In stock"×3 attempts

      Else

      No steps

Run results

Not run

0 of 10 results

  1. 1Navigate
  2. 2Evaluate JavaScript
  3. 3 › each 1If Conditionbook 1
  4. each 1 › then 1Navigatebook 1
  5. each 1 › then 2Extract Textbook 1
  6. 3 › each 1If Conditionbook 2
  7. 3 › each 1If Conditionbook 3
  8. each 1 › then 1Navigatebook 3
  9. each 1 › then 2Extract Textbook 3
  10. 3Repeat for Each Item

Replay of two runs recorded on November 17, 2026 with Owl Browser 1.4.1 and the Node SDK 2.3.0 FlowExecutor. Timings are the recorded ones; the replay is paced for reading. Nothing on this page talks to a browser.

  • Passing run: passed in 2.5 s, all 10 results passed. Price check: book 1 Then, book 2 Else, book 3 Then. Retry used: "Extract Text" on book 1 passed on attempt 2.
  • Failing run: failed after 19.4 s at step 3 › each 1 › then 2 (Extract Text): Expectation failed: Expected to contain "In stock", got "" ("Extract Text" on book 1 failed after 3 attempts). Recorded with the stock check's selector changed from .product_main .availability to .product_main .stock-status, which the page does not have.

Built to run many sessions on one instance

One container holds the whole stack. Each browser context is isolated from the others, so one instance can serve many accounts, test runs or agents at the same time.

Your code and agents

outside the container

REST, Node SDK, Python SDK, MCP clients, WebSocket

Docker container · linux/amd64

nginx

port 80

Control panel, /api, /execute, /mcp, /ws

HTTP server (C99)

port 8080

Auth, rate limits, MCP, video streams

Browser core, Chromium 156

up to 256 contexts

  • ctx 1own profile, proxy
  • ctx 2own profile, proxy
  • ctx 3own profile, proxy
  • … ctx 256own profile, proxy

Tor service on :9050 for contexts with is_tor

Request path inside the image. nginx serves the panel and forwards API calls; the C server keeps a pool of 64 socket connections to the browser so commands for different contexts run in parallel. On Enterprise you run this image on your own infrastructure.

Three ways to drive it

Run the container, then call it from a shell, from code, or from an MCP client. Each sample below runs the same loop on books.toscrape.com: open a context, load the page, observe, act by handle.

Reach your instance

On a hosted plan, Olib AI runs the instance and the customer portal shows its endpoint and API token. On Enterprise, the self-hosted plan, you pull the image from our registry and run it yourself; the token must be at least 32 characters. The panel is then at http://localhost:8080.

docker
docker login us-registry.owlbrowser.net   # account email + Docker Access Token from the portal
docker run -d --name owl-browser -p 8080:80 \
  -e OWL_HTTP_TOKEN="$OWL_HTTP_TOKEN" \
  -e OWL_PANEL_PASSWORD="$OWL_PANEL_PASSWORD" \
  -e OWL_TLS_ENABLED=false \
  -e OWL_LICENSE_CONTENT="$(base64 -w 0 license.olic)" \
  us-registry.owlbrowser.net/owl-browser:latest

MCP tool profiles

Tools exposed per OWL_MCP_PROFILE value
OWL_MCP_PROFILETools
agent (default)21
automation43
webdev37
full82

Counted from a live tools/list on 2026-11-17 against a pre-release build of Owl Browser 1.4.1.

agent-loop.sh
export OWL=http://localhost:8080
owl() {
  curl -s -X POST "$OWL/execute/$1" \
    -H "Authorization: Bearer $OWL_HTTP_TOKEN" \
    -H "Content-Type: application/json" -d "$2"
}
CTX=$(owl browser_create_context '{"render_mode":"agent"}' | jq -r .result.context_id)
owl browser_navigate "{\"context_id\":\"$CTX\",\"url\":\"https://books.toscrape.com/\",\"wait_until\":\"load\"}" > /dev/null
owl browser_observe "{\"context_id\":\"$CTX\"}" | jq -r .result.render | head -n 3
owl browser_close_context "{\"context_id\":\"$CTX\"}"
output (real run)
# All products | Books to Scrape - Sandbox · books.toscrape.com · scroll 0/2549
control "We love being scraped!" [#x3 ~inferred]
  link "Books to Scrape" [#l4]
{"success":true,"result":true}

Every tool is POST /execute/<tool> with a JSON body. The raw response wraps the result: browser_create_context returns an object whose context_id you pass to every later call. API reference

Fingerprint tests we publish

No browser is undetectable on every site. What we can show is how Owl reads to a public fingerprinting suite, next to the tools people usually start with. These are unedited CreepJS captures from our benchmark run.

Owl Browser, macOS profile
CreepJS Headless and Worker panels for Owl Browser: 38% like headless, 0% headless
0% headless, 0% stealth. The worker reports the same Chrome 147 on macOS and an Apple M4 GPU as the page.
Playwright Chromium, default settings
CreepJS Headless and Worker panels for Playwright Chromium: 94% like headless
100% headless. The worker user agent says HeadlessChrome 145 and the GPU is SwiftShader, a software renderer.
CreepJS headless and stealth scores, lower is better
BrowserLike headlessHeadlessStealth
Owl Browser (macOS profile)38%0%0%
Playwright Chromium94%100%0%
Puppeteer Chrome50%100%0%
Playwright + stealth plugin56%33%80%
Puppeteer + stealth plugin50%33%80%

CreepJS scores, lower is better. "Stealth" is how strongly CreepJS detects patches made to hide automation. Run of 2026-07-07 with Owl Browser 1.3.0.

The benchmark page has the full captures for macOS, Windows and Linux profiles, the agentic task results, and how each run was made.

See the benchmark

A control panel in every container

Run any tool by hand, watch the browser live, build flows without code, and connect agents. The same panel ships in the image; nothing to install. Select a capture to see it full size.

Flow designer, after a run. A four-step flow (Navigate, Wait for Network Idle, Get Page Info, Extract Text) run against example.com: 4 of 4 passed in 846 ms, with the time of each step and the live view of the page.
Live view with element picker. Picking an element on en.wikipedia.org/wiki/Owl in the live view. The panel offers its selector (#mwAQ) or its exact coordinates to the Click tool.Dark theme capture.
Connect via MCP. The panel shows this instance's OAuth endpoints and the commands to check the MCP endpoint with curl or the MCP Inspector.
Built-in IPC tests. A smoke run of the browser protocol tests from the panel: 5 of 5 passed in 2.27 s, with latency percentiles. Full, benchmark, stress, leak-check and parallel modes run the same way.

Capture

187 tools, grouped by what they do

The same tools are available over REST, both SDKs and WebSocket; MCP profiles expose curated subsets. Each name links to its reference with parameters and examples.

Browse all tools

What customers run on it

“At GC Transportation, our dispatchers and managers rely on dozens of different portals to track trucks, manage rides, and handle operations. Deploying Owl Browser across our enterprise was a game-changer. It securely integrates with our internal tools to automate repetitive tasks like invoicing, driver billing, and logistics routing. Owl Browser gave us our time back.”

Dariece, CEO, GC Transport Inc

“Managing the backend of LaFrique Market used to require constant tab-switching between our website dashboard, vendor portals, and accounting software. With Owl Browser, we've automated the entire retail lifecycle. From the moment a customer places an order, Owl instantly processes the invoice, updates our stock levels, and even alerts our vendors. It has completely streamlined our daily operations.”

Ibrahim, CEO, LaFrique Market

Pricing

Monthly plans, hosted for you or self-hosted on Enterprise. Starter and Business get their own AWS instance in the region you choose, deployed within 24 hours. Try it first: $0.99 for 14 days.

Compare plans
Owl Browser plans and prices in USD
PlanPriceRuns onLimit
Trial$0.99 for 14 daysShared, hosted by Olib AI5 concurrent browser contexts
Developer$9.99 per monthShared, hosted by Olib AI5 concurrent browser contexts
Starter$199.99 per monthDedicated 32 GB AWS instanceBounded by the instance
Business$499.99 per monthDedicated 64 GB AWS instanceBounded by the instance
Enterprise$4,999.00 per monthYour infrastructure (Docker)10 seats

Questions buyers ask

More on the FAQ page, or ask us directly at sales@olib.ai.

How is Owl Browser deployed?
Hosted for you by Olib AI, or self-hosted on Enterprise. Developer Trial and Developer run on shared hosting. Starter and Business each get one dedicated AWS EC2 instance (32 GB or 64 GB) in the AWS region you choose, deployed within 24 hours of purchase, with its own endpoint. On Enterprise you pull one Docker image (linux/amd64) from us-registry.owlbrowser.net (or the EU registry), set OWL_HTTP_TOKEN and OWL_PANEL_PASSWORD, and pass your license as OWL_LICENSE_CONTENT.
How do AI agents use it?
Point any MCP client at /mcp on your own Owl instance, hosted or self-hosted (Streamable HTTP, Bearer token or OAuth 2.1); there is no shared public MCP endpoint at owlbrowser.net. The agent creates a context, navigates, calls browser_observe to read the page as OwlMark text, and clicks or types by handle. OWL_MCP_PROFILE picks how many tools it sees, from 21 (agent) to 82 (full). Agents built in code can use the Node or Python SDK.
How many browser sessions can one instance run?
Developer (and the trial) is limited to 5 concurrent browser contexts. On Starter and Business the license does not cap concurrency; the dedicated instance does: 50+ concurrent sessions on Starter (32 GB) and 100+ concurrent sessions on Business (64 GB). The engine's documented limit is 256 isolated contexts per instance, each with its own cookies, storage, proxy and fingerprint profile.
Can I keep my Playwright or Puppeteer scripts?
Not unchanged. Owl Browser is driven through its own API (187 tools over REST, SDKs and MCP), not the Chrome DevTools Protocol, so scripts are ported to SDK calls. The concepts map closely: contexts, navigate, click and type with CSS selectors, waits, screenshots. If you need a drop-in browser for existing Playwright or Puppeteer code, use Owl Light, our free Chromium build for CDP.
Is it undetectable?
No browser is undetectable on every site, and we do not claim it. Owl applies device profiles in C++ inside Chromium, and we publish the fingerprint tests we run, next to how stock Playwright and Puppeteer score, on the benchmark page. Test it on the sites you care about with the trial.
What does it cost?
All plans are monthly. The Developer Trial is $0.99, charged once, for 14 days. Developer is $9.99 per month (or $99.99/year) on shared hosting. Starter ($199.99) and Business ($499.99) per month each include a dedicated AWS instance. Enterprise, the only self-hosted plan, is $4,999.00 per month through sales. Full pricing

Run your own workload on it

The Developer Trial gives you an instance hosted by Olib AI for 14 days for $0.99, charged once. Point your scripts or your agent at it and judge it on the sites you actually automate. To self-host, talk to sales about Enterprise.

Only need a browser for existing Playwright or Puppeteer code? Owl Light is a free, drop-in Chromium build for Playwright and Puppeteer with the same source-level fingerprint engine (CDP only: no API server, panel, CAPTCHA solving or LLM).

Talk to sales

Tell us what you automate and at what scale; we will reply with how Owl fits and what it costs.

By submitting this form, you agree to our Terms of Service and Privacy Policy.