← Blog

BLOG

Web Based Tool: What It Means for Browser Automation

A web based tool runs in the browser, not on your machine. Here's what that means for automation, CDP access, and hosted Chromium runtimes.

9 min readRemote Browser
Ivory computer towers connected across terracotta platforms in a quiet desert landscape
The infrastructure behind your browserREMOTE BROWSER / ILLUSTRATION

A web based tool is software you reach through a browser instead of installing on your own machine. The app logic runs on a server; your browser is the client. That definition matters more than it sounds, because once you start automating the web, "web based" splits into two very different questions: is the *tool* web based, and is the *browser* it drives web based? This guide answers the first quickly and spends most of its time on the second, since that is where most automation projects actually get stuck.

If you are evaluating a web based tool for browser automation, the practical question is whether it gives you a real browser you can drive programmatically — over CDP, with Playwright or Puppeteer — without you provisioning Chrome, patching it, and babysitting it on a VM. That is the gap a hosted Chromium runtime fills. The rest of this article explains the trade-offs, the production criteria that matter, and how to wire it up.

What "web based tool" actually covers

The term is broad, and that breadth is why it is a weak search term on its own. People use it for at least four distinct things:

  • SaaS applications — Figma, Notion, Google Docs. You open a URL, the app runs server-side, your browser renders it.
  • Browser-based IDEs and dev tools — GitHub Codespaces, StackBlitz, browser devtools panels. The tool is web based but the code runs somewhere else.
  • Remote browser products — a real Chromium instance hosted on a provider's infrastructure that you connect to and control. This is the category that matters for automation.
  • Web based automation platforms — no-code or low-code tools that record clicks in a browser and replay them.

For an engineer building AI agents or test harnesses, only the third category is load-bearing. The first two are conveniences. The fourth usually hits a ceiling the moment a site changes or a login flow needs a persistent session.

Why "web based" is the wrong axis for automation

The instinct when you hear "web based tool" is to think about where the *interface* lives. For automation, the axis that matters is where the *browser process* lives and who owns its lifecycle.

A local Playwright script is not a web based tool, but it drives a browser. A hosted runtime is a web based tool in the sense that you reach it over the network, but what you actually get is a browser process you control. The distinction that matters in production is:

DimensionLocal browser automationHosted (web based) browser runtime
Browser process runs onYour laptop or CI runnerProvider infrastructure
Chrome version managementYou pin, patch, upgradeProvider maintains
Session persistenceTied to your machineConfigurable profiles, survives worker restarts
ConcurrencyBounded by local CPU/RAMBounded by your plan; see /pricing
Live debuggingLocal devtoolsRemote viewer over the network
Network egressYour IPConfigurable proxy settings
Failure isolationOne crash kills the runSession isolation per browser

The right column is what people mean when they say they want a web based tool for automation. It is not about a nicer UI. It is about moving the browser out of your process so that scaling, persistence, and debugging stop being your problem.

The production criteria that separate real runtimes from demos

Most "web based" automation tools look identical in a five-minute demo. They diverge on the things that only show up at scale. Here is what to check before you commit.

1. Real CDP access, not a wrapper

If the tool only exposes a click-and-type API, you are locked into its abstraction. You want a Chrome DevTools Protocol endpoint you can attach to directly, so Playwright, Puppeteer, Selenium, or your own CDP client can drive it. The Chrome DevTools Protocol is the contract; anything that hides it is a liability when you need to intercept network requests, evaluate script in a specific frame, or read console logs.

2. Session lifecycle you control

A browser session should be something you create, use, and explicitly stop. Implicit timeouts and opaque billing are how costs creep. You want an API that returns a session you can query and tear down, and metering you can reason about. Remote Browser meters by browser-hour; current rates and plan limits live on /pricing.

3. Persistent profiles

Logins are the single biggest source of flaky automation. A runtime that supports persistent browser profiles — cookies, localStorage, saved credentials — lets an agent resume a session instead of re-authenticating on every run. This is the difference between a demo and a workflow that survives a week.

4. Configurable network and browser settings

Proxy configuration, user-agent, and other browser settings should be adjustable per session. Be careful with vendor claims here: "stealth" and "anti-detection" mean different things to different providers. Ask what is actually configurable and test it against your target sites rather than trusting the marketing.

5. Live viewer and observability

When an agent fails at step 14 of a 20-step task, you need to see what the browser saw. A live viewer plus session recordings turns a black-box failure into a debuggable one. Without it, you are reading logs and guessing.

6. Isolation between sessions

Two agents running concurrently must not share cookies, storage, or process state. Session isolation is table stakes for anything multi-tenant.

Wiring a web based runtime into Playwright

The concrete payoff of a hosted runtime is that your Playwright code barely changes. You swap launch() for connectOverCDP() and point it at the remote endpoint. Here is the shape of it in TypeScript:

import { chromium, type Browser, type Page } from "playwright";

interface SessionInfo {
  cdpUrl: string;
  sessionId: string;
}

// Your runtime's API returns a CDP WebSocket URL for a new session.
async function createSession(): Promise<SessionInfo> {
  const res = await fetch(`${process.env.RUNTIME_API}/sessions`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.RUNTIME_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ profile: "checkout-agent" }),
  });
  if (!res.ok) throw new Error(`session create failed: ${res.status}`);
  return res.json();
}

async function runTask(): Promise<void> {
  const { cdpUrl, sessionId } = await createSession();
  let browser: Browser | undefined;

  try {
    browser = await chromium.connectOverCDP(cdpUrl);
    const context = browser.contexts()[0] ?? (await browser.newContext());
    const page: Page = context.pages()[0] ?? (await context.newPage());

    await page.goto("https://example.com", { waitUntil: "domcontentloaded" });
    await page.getByRole("link", { name: "Sign in" }).click();
    // ... your agent or script logic here
  } finally {
    // Disconnect the client; the remote session is stopped via the API.
    await browser?.close();
    await fetch(`${process.env.RUNTIME_API}/sessions/${sessionId}`, {
      method: "DELETE",
      headers: { Authorization: `Bearer ${process.env.RUNTIME_API_KEY}` },
    });
  }
}

runTask().catch((err) => {
  console.error(err);
  process.exit(1);
});

A few things worth noting. connectOverCDP attaches to an existing browser rather than launching one, so browser.close() disconnects your client — it does not necessarily terminate the remote session. Stop the session through the runtime's API so you are not billed for an idle browser. The Playwright docs on connecting over CDP cover the Chromium-only caveat and the context handling.

If you are moving from a local script, the migration is mostly deleting playwright install from your CI and adding a session-create call. The full setup path is covered in /blog/remote-browser-for-ai-agents.

Where a web based runtime fits — and where it doesn't

Hosted browsers are not universally better. They are better when the cost of managing Chrome exceeds the cost of the runtime, and worse when you need something only a local browser can do.

Use a hosted runtime when:

  • You run many concurrent sessions and do not want to provision VMs.
  • You need sessions to outlive a single worker or CI job.
  • You want a live viewer and recordings without building them.
  • You need configurable proxies or network settings per session.
  • Your agents run on infrastructure you do not fully control (serverless, ephemeral containers).

Stay local when:

  • You are testing browser extensions that require a specific local profile.
  • You need hardware-level access (WebUSB, certain WebGL paths) that hosted environments may not expose.
  • Your workload is a single short script run once a day and the overhead is not worth it.

The honest framing: a web based tool is a trade of control for operational simplicity. Make that trade deliberately.

Common failure modes and how to avoid them

Even with a solid runtime, teams hit the same walls. These are worth designing around from day one.

  • Leaking sessions. If your code throws before the cleanup block, the remote browser keeps running. Wrap session creation in try/finally and add a server-side max lifetime as a backstop.
  • Assuming `browser.close()` stops billing. It usually does not. Call the session-stop endpoint explicitly.
  • Re-authenticating every run. Use persistent profiles for anything behind a login. Replaying a login flow on every task is slow and fragile.
  • Ignoring the viewer until something breaks. Watch a few runs live during development. You will catch selector and timing bugs that logs hide.
  • Hardcoding concurrency. Your plan caps concurrent sessions; see /pricing for current limits rather than assuming a number.

How to evaluate a web based tool in an afternoon

You do not need a two-week trial to know whether a runtime will work. Run this sequence:

  1. Create a session via the API and confirm you get a CDP endpoint back.
  2. Connect with Playwright connectOverCDP and load a page that requires JavaScript.
  3. Run the same task twice with a persistent profile and confirm the second run skips login.
  4. Open the live viewer while a session is running and confirm you can see it.
  5. Kill your client process mid-run and check whether the session is cleaned up or leaks.
  6. Run two sessions concurrently and confirm cookies do not bleed between them.

If all six pass, the runtime is credible. If any fail, you have found the thing that will page you at 2 a.m.

Bottom line

"Web based tool" describes where software runs, but for automation the question is where the *browser* runs and who owns its lifecycle. A hosted Chromium runtime gives you real CDP access, persistent profiles, session isolation, and a live viewer without you managing Chrome. The trade-off is control and per-hour cost, which you should weigh against the engineering time you would otherwise spend on infrastructure. Start with the six-step evaluation above, read the documentation for the API surface, and check /pricing before you size a plan. If you want the broader context on why this layer exists, /blog/remote-web-browser covers the runtime model in more depth.