Browser Use is the framework. humanbrowser is the cloud that runs it for you.

Two layers, not two products

Browser Use is a Python OSS framework — a library you import into your code to give an LLM agent control of a Playwright browser. $17M seed in February 2026, well-maintained, widely adopted. The team built one of the cleanest agent-loop abstractions in the space and they ship updates fast. Their scope is the framework.

humanbrowser is the cloud runtime that sits underneath frameworks like Browser Use. Managed Chrome on Xvfb, a pooled session lifecycle, residential connection per session, captcha solving billed only on success, a live viewer with one-click human takeover, a per-site knowledge base that auto-tunes across 277+ recorded trajectories, and a CUA + DOM hybrid that decides per site which backend to use. Our scope is the infrastructure the framework needs to run in production.

That means the honest framing is "complementary, not competitive". Many production deployments use both: Browser Use library for the agent-loop on a developer's laptop, humanbrowser cloud for shared infrastructure and the HITL viewer. We even run a fork of the Browser Use runner internally as one of the execution paths inside the hosted agent.

What the Browser Use library does not ship

None of that is criticism of Browser Use's scope. A framework should be a framework. It is a description of what is left for you to build when the library ends. humanbrowser is what we built so we did not have to keep building it for each new agent project.

The integration: Browser Use script + humanbrowser cloud

What you get from the cloud layer

• Self-serve: try it for $1, no demo call. Top up from $5, balance never expires.
• Public per-line-item pricing — $0.10/browser-hour, $4/GB residential connection, $0.005 per solved interactive challenge, $0.02 per agent step with the AI included. Median task on our production: about 8 agent steps, $0.24 all-in (Sep 2026).
• Open-source core — @virixlabs/humanbrowser on npm (Apache-2.0). Run the same runner locally for free, point at the cloud only when you need shared infra.
• CUA + DOM hybrid execution — Computer-Use-Agent path (xdotool + scrot on Xvfb, our in-house Computer-Use model) for canvas-heavy / drag-and-drop / shadow-DOM-heavy targets; cheap DOM path for the rest. Auto-routed per domain via the knowledge base — your Browser Use script does not need to know which is being used.
• native A2A (v0.3) endpoint — agent.humanbrowser.cloud/a2a plus discoverable agent card at /.well-known/agent-card.json. Claude Code, Codex, LangGraph, CrewAI, OpenAI Agents SDK, Google ADK all plug in straight.
• Live viewer + human takeover — MJPEG preview per session, one-click HITL takeover, free. Built for user-authorized tasks where a human stays in the loop.
• Public benchmarks — 6 cloud-browser engines × 12 LLMs, raw data + methodology at github.com/VirixLabs/stealth-benchmark. Plus our LLM cost-perf benchmark (12 sessions, ~$4 spend) found google/gemini-2.5-flash-lite at $0.023/agentic task as the cost-leader.
• Self-improving per-site knowledge base — every successful task writes structured notes that the next session loads before planning. 277+ session trajectory recordings already in the corpus, feeding the auto-router that decides CUA vs DOM.

Pricing — what self-hosted Browser Use actually costs

This is not a gotcha. If your volume is steady, your team has someone who already operates a residential proxy account, and you have the headroom to staff a browser-infra rotation — self-hosted Browser Use is cheaper per task. If your volume is bursty, your team is small, or you do not want a person on call for headless-Chrome OOMs at 3am — humanbrowser is cheaper end-to-end once you count the operations time.

Public benchmarks — what we publish that the framework layer cannot

The Browser Use repo is a framework — benchmarks at that layer are about agent-loop quality, which is genuinely their job. Cloud-runtime benchmarks (which engine survives which site, which LLM is the cost-leader for agentic tasks, which trajectories reuse across runs) are only meaningful when you operate the runtime. We do, so we publish them.

When Browser Use alone is the better choice

This page exists to help you make a real decision, not to win every comparison. Browser Use alone wins these:

• You already run browser automations on a self-hosted VPS with your own proxy infrastructure. The marginal value of a cloud runtime is small once you have wired the whole stack yourself. Stay on Browser Use.
• You want zero vendor lock-in and full code ownership of every layer. The library is OSS and well-maintained — there is no reason to add a vendor if you do not need one. Choose them then.
• Your traffic is local-only / development / one-off scripts. A local Playwright is faster to iterate against than any remote endpoint. The library is the right tool.
• You have a strong reason to keep the agent loop on your own infra. Compliance, sensitive credentials, air-gapped environment. The library is the right shape for that.

When humanbrowser is the better choice

• You want to stop operating browser infrastructure. Headless Chrome, residential proxies, captcha-solver integration, session lifecycle, live viewers — all bundled, all billed per use.
• You want your Browser Use script to work without changing it. Point its CDP at humanbrowser and keep the rest of your code. The cloud handles proxies, captchas, and the viewer underneath.
• You want a live viewer with one-click human takeover as a first-class workflow. Free on every session. Built for user-authorized tasks where a human stays in the loop.
• You are building A2A-first. Your agent already speaks Agent2Agent — humanbrowser is reachable as another agent rather than as a Python library you import.
• You want CUA for the hard sites and cheap DOM for the rest, auto-routed. Per-site rules learn from 277+ trajectories — no config flag flipping.
• You want public benchmarks you can re-run. 6×12 stealth engines, LLM cost-per-task — all OSS, no vendor scoring its own homework.

Migration: Browser Use local to humanbrowser cloud in 30 minutes

If you already have a Browser Use-driven script, migration is one config swap. Keep your agent loop, your task description, your tool list. Change the browser config from a local Playwright launch to humanbrowser's CDP endpoint. Your script gets a clean residential connection, the right execution backend (CUA or DOM, auto-routed), the live viewer attached, and the human-takeover hook for free. Top up with $1, smoke-test one representative flow, then cut your highest-friction script over first. New flows can move to the A2A endpoint when you want to declare the goal instead of writing the loop.

Code: local Browser Use vs Browser Use on humanbrowser vs A2A handoff

from browser_use import Agent
from langchain_openai import ChatOpenAI

# You install Playwright, you run headless Chrome,
# you BYO proxy, you BYO captcha solver,
# you BYO viewer + HITL takeover.
agent = Agent(
    task="Log in to target.com and export CSV",
    llm=ChatOpenAI(model="gpt-4o"),
)
result = await agent.run()

from browser_use import Agent, Browser, BrowserConfig
from langchain_openai import ChatOpenAI

browser = Browser(config=BrowserConfig(
    cdp_url="wss://agent.humanbrowser.cloud/cdp"
                "?token=$HB_TOKEN&country=gb"
                "&profile=reports-bot",
))

# Residential connection bundled, captcha solving bundled,
# live viewer attached, HITL takeover one click away.
agent = Agent(
    task="Log in to target.com and export CSV",
    llm=ChatOpenAI(model="gpt-4o"),
    browser=browser,
)
result = await agent.run()

const res = await fetch('https://agent.humanbrowser.cloud/a2a', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer ' + process.env.HB_TOKEN
  },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'login-1',
    method: 'tasks/send',
    params: {
      skill: 'login_and_extract',
      message: 'Log in to target.com and export CSV',
      country: 'gb',
      profile: 'reports-bot'
    }
  })
});
const { result } = await res.json();
// CUA/DOM auto-routed, residential connection,
// live viewer, result.artifacts has the CSV.

Left side: a script that depends on you operating headless Chrome + proxies + solver + viewer forever. Middle: the same script, runtime swapped to humanbrowser, zero rewrite. Right: the goal declared once, the agent loop deleted from your codebase entirely. Choose whichever shape fits the system you actually want to maintain.

FAQ