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.
- Engine status – Shows whether the browser engine is up: Ready, Starting, Offline or License required. The refresh button checks again.
- 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 +.
- Address bar –
- 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.
- 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.
- Theme – Switches the panel between System, Light and Dark.
- Tools – Run any single tool by hand: pick it, fill in its parameters and execute it against the live context.
- 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.
- Tests – Runs the IPC protocol test suite against the engine (smoke, full, benchmark, stress, leak check or parallel) and keeps the reports.
- 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.
- 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.
- 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.
- Selected tool – The tool’s category, its name, the API id you call it by (browser_navigate) and what it does.
- Code tab – The same request Execute sends, as code you can run from your own machine: Node.js, Python, cURL or JavaScript.
- 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.
- Execute – Runs the tool against the selected context. ⌘ Enter (Ctrl Enter on Windows and Linux) runs it from anywhere in the form.
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_observereturns the page as OwlMark text with short handles (b3,l5) thatbrowser_clickandbrowser_typeaccept. 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.

browser_screenshot), cropped.The response also carries 99 handles. The two for the first book:
[
{
"token": "l116",
"role": "link",
"name": "A Light in the ..."
},
{
"token": "b119",
"role": "button",
"name": "Add to basket"
}
]# 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]Measured size of the same page
| Page | OwlMark render | Full observe response | Page 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
browser_create_contextOpen an isolated session. MCP clients get the agent render by default; REST and SDK callers pass render_mode "agent" or "both".
- 2
browser_navigateLoad the page, optionally waiting for load or network idle.
- 3
browser_observeRead the page as OwlMark text plus a handle table of everything clickable or typeable.
- 4
browser_click / browser_typeAct 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
Steps 3
- Navigate, step 1
Open the shop
https://books.toscrape.com/
×2 attempts30000ms timeout - 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) - 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
- If Condition, step 3 › each 1
Is it under £52?
If Previous result.price Less Than 52
Then
- Navigate, step 3 › each 1 › then 1
Open the book's page
${vars.book.url}
×2 attempts30000ms timeout - 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 run0 of 10 results
- 1Navigate
- 2Evaluate JavaScript
- 3 › each 1If Conditionbook 1
- each 1 › then 1Navigatebook 1
- each 1 › then 2Extract Textbook 1
- 3 › each 1If Conditionbook 2
- 3 › each 1If Conditionbook 3
- each 1 › then 1Navigatebook 3
- each 1 › then 2Extract Textbook 3
- 3Repeat for Each Item
{
"name": "Check book prices",
"description": "Open Books to Scrape, list the first 3 books, and for each one under £52 open its page and check it is in stock.",
"steps": [
{
"id": "step_open_shop",
"type": "browser_navigate",
"selected": true,
"description": "Open the shop",
"timeoutMs": 30000,
"retry": {
"maxAttempts": 2,
"backoffMs": 1000
},
"url": "https://books.toscrape.com/",
"wait_until": "load"
},
{
"id": "step_list_books",
"type": "browser_evaluate",
"selected": true,
"description": "List the first 3 books",
"expected": {
"length": 3
},
"capture": "books",
"expression": "[...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, '')) }))"
},
{
"id": "step_each_book",
"type": "for_each",
"selected": true,
"description": "Check each book",
"source": "${vars.books}",
"item_var": "book",
"body": [
{
"id": "step_price_check",
"type": "condition",
"selected": true,
"condition": {
"source": "previous",
"field": "price",
"operator": "less_than",
"value": 52
},
"onTrue": [
{
"id": "step_open_book",
"type": "browser_navigate",
"selected": true,
"description": "Open the book's page",
"timeoutMs": 30000,
"retry": {
"maxAttempts": 2,
"backoffMs": 1000
},
"url": "${vars.book.url}",
"wait_until": "load"
},
{
"id": "step_stock",
"type": "browser_extract_text",
"selected": true,
"description": "Check it is in stock",
"expected": {
"contains": "In stock"
},
"retry": {
"maxAttempts": 3,
"backoffMs": 1000
},
"selector": ".product_main .availability"
}
],
"description": "Is it under £52?"
}
]
}
]
}The flow file the panel exports. Import it back into the panel, or run it with FlowExecutor from either SDK.
// Owl Browser flow "Check book prices" run by the Node SDK FlowExecutor
// Install: npm install @olib-ai/owl-browser-sdk (Node >= 20.18.1, ES module)
// Save as: check-book-prices-runner.mjs
// Run: export OWL_HTTP_TOKEN=<your token>; node check-book-prices-runner.mjs
import { FlowExecutor, OwlBrowser } from '@olib-ai/owl-browser-sdk';
// The flow exactly as exported by the control panel (flat step format).
const FLOW = {
name: 'Check book prices',
description: 'Open Books to Scrape, list the first 3 books, and for each one under £52 open its page and check it is in stock.',
steps: [
{
id: 'step_open_shop',
type: 'browser_navigate',
selected: true,
description: 'Open the shop',
timeoutMs: 30000,
retry: { maxAttempts: 2, backoffMs: 1000 },
url: 'https://books.toscrape.com/',
wait_until: 'load',
},
{
id: 'step_list_books',
type: 'browser_evaluate',
selected: true,
description: 'List the first 3 books',
expected: { length: 3 },
capture: 'books',
expression: '[...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, \'\')) }))',
},
{
id: 'step_each_book',
type: 'for_each',
selected: true,
description: 'Check each book',
source: '${vars.books}',
item_var: 'book',
body: [
{
id: 'step_price_check',
type: 'condition',
selected: true,
condition: { source: 'previous', field: 'price', operator: 'less_than', value: 52 },
onTrue: [
{
id: 'step_open_book',
type: 'browser_navigate',
selected: true,
description: 'Open the book\'s page',
timeoutMs: 30000,
retry: { maxAttempts: 2, backoffMs: 1000 },
url: '${vars.book.url}',
wait_until: 'load',
},
{
id: 'step_stock',
type: 'browser_extract_text',
selected: true,
description: 'Check it is in stock',
expected: { contains: 'In stock' },
retry: { maxAttempts: 3, backoffMs: 1000 },
selector: '.product_main .availability',
},
],
description: 'Is it under £52?',
},
],
},
],
};
const browser = new OwlBrowser({
url: 'http://localhost:8080',
token: process.env.OWL_HTTP_TOKEN,
});
await browser.connect();
const contextId = await browser.createContext();
try {
const executor = new FlowExecutor(browser, contextId);
const result = await executor.execute(FlowExecutor.parseFlow(FLOW));
for (const step of result.steps) {
const status = step.success ? 'ok ' : 'FAIL';
const error = step.error ? ` - ${step.error}` : '';
console.log(`${status} step ${step.stepIndex} ${step.toolName} (${Math.round(step.durationMs)} ms)${error}`);
}
if (result.skipped) console.log(`flow skipped: ${result.error}`);
else if (result.success) console.log(`flow passed in ${Math.round(result.totalDurationMs)} ms`);
else console.log(`flow failed: ${result.error}`);
process.exitCode = result.success ? 0 : 1;
} finally {
await browser.closeContext({ context_id: contextId });
await browser.close();
}What the panel’s "Export as script" produces for this flow: the SDK FlowExecutor runs the embedded flow. We ran it against our own server before publishing; only the server URL changed.
# Owl Browser flow "Check book prices" run by the Python SDK FlowExecutor
# Install: pip install owl-browser (Python >= 3.12)
# Save as: check_book_prices_runner.py
# Run: export OWL_HTTP_TOKEN=<your token>; python3 check_book_prices_runner.py
import asyncio
import json
import os
import tempfile
from owl_browser import FlowExecutor, OwlBrowser, RemoteConfig
# The flow exactly as exported by the control panel (flat step format).
FLOW = {
"name": "Check book prices",
"description": "Open Books to Scrape, list the first 3 books, and for each one under £52 open its page and check it is in stock.",
"steps": [
{
"id": "step_open_shop",
"type": "browser_navigate",
"selected": True,
"description": "Open the shop",
"timeoutMs": 30000,
"retry": {"maxAttempts": 2, "backoffMs": 1000},
"url": "https://books.toscrape.com/",
"wait_until": "load",
},
{
"id": "step_list_books",
"type": "browser_evaluate",
"selected": True,
"description": "List the first 3 books",
"expected": {"length": 3},
"capture": "books",
"expression": "[...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, '')) }))",
},
{
"id": "step_each_book",
"type": "for_each",
"selected": True,
"description": "Check each book",
"source": "${vars.books}",
"item_var": "book",
"body": [
{
"id": "step_price_check",
"type": "condition",
"selected": True,
"condition": {
"source": "previous",
"field": "price",
"operator": "less_than",
"value": 52,
},
"onTrue": [
{
"id": "step_open_book",
"type": "browser_navigate",
"selected": True,
"description": "Open the book's page",
"timeoutMs": 30000,
"retry": {"maxAttempts": 2, "backoffMs": 1000},
"url": "${vars.book.url}",
"wait_until": "load",
},
{
"id": "step_stock",
"type": "browser_extract_text",
"selected": True,
"description": "Check it is in stock",
"expected": {"contains": "In stock"},
"retry": {"maxAttempts": 3, "backoffMs": 1000},
"selector": ".product_main .availability",
},
],
"description": "Is it under £52?",
},
],
},
],
}
def load_flow():
"""FlowExecutor.load_flow(path) is the SDK's public loader, so go through a file."""
with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False, encoding="utf-8") as f:
json.dump(FLOW, f)
try:
return FlowExecutor.load_flow(f.name)
finally:
os.unlink(f.name)
async def main() -> int:
flow = load_flow()
config = RemoteConfig(
url="http://localhost:8080",
token=os.environ["OWL_HTTP_TOKEN"],
)
async with OwlBrowser(config) as browser:
context_id = await browser.create_context()
try:
executor = FlowExecutor(browser, context_id)
result = await executor.execute(flow)
finally:
await browser.close_context(context_id=context_id)
for step in result.steps:
status = "ok " if step.success else "FAIL"
error = f" - {step.error}" if step.error else ""
print(f"{status} step {step.step_index} {step.tool_name} ({step.duration_ms:.0f} ms){error}")
if result.skipped:
print(f"flow skipped: {result.error}")
elif result.success:
print(f"flow passed in {result.total_duration_ms:.0f} ms")
else:
print(f"flow failed: {result.error}")
return 0 if result.success else 1
raise SystemExit(asyncio.run(main()))What the panel’s "Export as script" produces for this flow: the SDK FlowExecutor runs the embedded flow. We ran it against our own server before publishing; only the server URL changed.
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 .availabilityto.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
Docker container · linux/amd64
nginx
port 80
/api, /execute, /mcp, /wsHTTP server (C99)
port 8080
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
A fingerprint per context
1,400 device profiles across Chrome 143–156. Each context gets one at creation, with its own canvas, WebGL, audio and font seeds.
Render modes
pixel for screenshots and video, agent for OwlMark only, both when an agent also needs pixels. Chosen per context.
Proxies and Tor
http, https, socks4, socks5 and socks5h (remote DNS) per context. Tor runs inside the container on port 9050; set is_tor for a context to route through it.
Network control
Block, mock or redirect requests with URL-pattern rules, and log traffic per context.
browser_add_network_rulebrowser_enable_network_interceptionbrowser_get_network_log
Profiles and cookies
Save a context's fingerprint, cookies and settings to a profile and load it later, so a logged-in identity survives restarts.
Video and live view
Record H.264 video of a session, or watch it live as an MJPEG stream in the panel or any client.
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 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:latestMCP tool profiles
| OWL_MCP_PROFILE | Tools |
|---|---|
agent (default) | 21 |
automation | 43 |
webdev | 37 |
full | 82 |
Counted from a live tools/list on 2026-11-17 against a pre-release build of Owl Browser 1.4.1.
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\"}"# 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
// npm install @olib-ai/owl-browser-sdk (Node 20.18.1+, save as agent-loop.mjs)
import { OwlBrowser } from '@olib-ai/owl-browser-sdk';
const browser = new OwlBrowser({
url: 'http://localhost:8080',
token: process.env.OWL_HTTP_TOKEN,
});
const ctx = await browser.createContext({ render_mode: 'agent' });
try {
await browser.navigate({ context_id: ctx, url: 'https://books.toscrape.com/', wait_until: 'load' });
// What an agent reads: OwlMark text plus a table of clickable handles.
const page = await browser.observe({ context_id: ctx });
console.log(page.render.split('\n')[0]);
console.log(page.handles.length, 'handles');
// Act by handle, then observe again.
const next = page.handles.find((h) => h.name === 'next');
await browser.click({ context_id: ctx, selector: next.token });
await browser.waitForUrl({ context_id: ctx, url_pattern: 'page-2' });
const after = await browser.observe({ context_id: ctx });
console.log(after.metadata.url, after.handles.length, 'handles');
} finally {
await browser.closeContext({ context_id: ctx });
await browser.close();
}# All products | Books to Scrape - Sandbox · books.toscrape.com · scroll 0/2549
96 handles
https://books.toscrape.com/catalogue/page-2.html 127 handles@olib-ai/owl-browser-sdk 2.3.0, ESM only. Every tool is a method (browser_wait_for_url → waitForUrl) that takes the tool's snake_case parameters; createContext() returns the id string. Node SDK guide
# pip install owl-browser (Python 3.12+)
import asyncio, os
from owl_browser import OwlBrowser, RemoteConfig
async def main():
config = RemoteConfig(url="http://localhost:8080",
token=os.environ["OWL_HTTP_TOKEN"])
async with OwlBrowser(config) as browser:
ctx = await browser.create_context(render_mode="agent")
try:
await browser.navigate(context_id=ctx, url="https://books.toscrape.com/", wait_until="load")
page = await browser.observe(context_id=ctx)
print(page["render"].splitlines()[0])
print(len(page["handles"]), "handles")
nxt = next(h for h in page["handles"] if h["name"] == "next")
await browser.click(context_id=ctx, selector=nxt["token"])
await browser.wait_for_url(context_id=ctx, url_pattern="page-2")
after = await browser.observe(context_id=ctx)
print(after["metadata"]["url"], len(after["handles"]), "handles")
finally:
await browser.close_context(context_id=ctx)
asyncio.run(main())# All products | Books to Scrape - Sandbox · books.toscrape.com · scroll 0/2549
99 handles
https://books.toscrape.com/catalogue/page-2.html 127 handlesowl-browser 2.3.0, async with aiohttp, Python 3.12+. Methods are the tool names without the browser_ prefix. Python SDK guide
# Claude Code (any MCP client that speaks Streamable HTTP works the same way)
claude mcp add --transport http owl-browser http://localhost:8080/mcp \
--header "Authorization: Bearer $OWL_HTTP_TOKEN"
# Check the endpoint: list the tools it exposes
curl -s -X POST http://localhost:8080/mcp \
-H "Authorization: Bearer $OWL_HTTP_TOKEN" \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | jq '.result.tools | length'21The MCP server is built into the HTTP server: Streamable HTTP at POST /mcp, protocol versions 2024-11-05 to 2026-07-28, Bearer token or OAuth 2.1. Choose the tool surface with OWL_MCP_PROFILE on the container.
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.


| Browser | Like headless | Headless | Stealth |
|---|---|---|---|
| Owl Browser (macOS profile) | 38% | 0% | 0% |
| Playwright Chromium | 94% | 100% | 0% |
| Puppeteer Chrome | 50% | 100% | 0% |
| Playwright + stealth plugin | 56% | 33% | 80% |
| Puppeteer + stealth plugin | 50% | 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 benchmarkA 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.
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.
Sessions
5Isolated contexts, each with its own fingerprint profile
Agent view
5OwlMark page text and clickable handles
Waiting
7Selectors, URLs, network idle, functions
Video and live view
11Recording and MJPEG live streams
Profiles and cookies
11Persist and restore identities
Network and proxies
17Interception, logging, proxies, Tor
browser_set_proxybrowser_add_network_rulebrowser_get_network_log
CAPTCHA
5Detect, classify and solve
AI and natural language
11Natural-language actions and page Q&A on an LLM endpoint you configure
Downloads and dialogs
10Files, alerts, confirms, prompts
Navigation and tabs
17Pages, history, tabs, popups, one-shot fetch
Content extraction
14Text, HTML, Markdown, JSON, screenshots, site crawl
Element state
8Visibility, attributes, positions
Interaction
23Click, type, pick, drag, keyboard, clipboard, uploads
Viewport, scroll and frames
14Scrolling, zoom, viewport, iframes, overlays
browser_scroll_to_elementbrowser_set_viewportbrowser_switch_to_frame
Fingerprint and locale
6Hardware fingerprint, timezone, location, weather
WebMCP
4Call tools a page exposes over WebMCP
HTTP and FTP client
6Requests and sessions without a browser page
License and server
13License, logs, restarts, built-in IPC tests
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.”
“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.”
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.
| Plan | Price | Runs on | Limit |
|---|---|---|---|
| Trial | $0.99 for 14 days | Shared, hosted by Olib AI | 5 concurrent browser contexts |
| Developer | $9.99 per month | Shared, hosted by Olib AI | 5 concurrent browser contexts |
| Starter | $199.99 per month | Dedicated 32 GB AWS instance | Bounded by the instance |
| Business | $499.99 per month | Dedicated 64 GB AWS instance | Bounded by the instance |
| Enterprise | $4,999.00 per month | Your 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?
OWL_HTTP_TOKEN and OWL_PANEL_PASSWORD, and pass your license as OWL_LICENSE_CONTENT.How do AI agents use it?
/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?
Can I keep my Playwright or Puppeteer scripts?
Is it undetectable?
What does it cost?
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.
- hello@owlbrowser.net
- Stone Mountain, GA
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.







