If you are automating a vendor portal that will never ship an API, write the flow as a Playwright script, and pay a model only for the step that breaks. A scripted flow costs nothing per run and fails loudly. A computer-use agent re-derives a path you already know on every run, bills you for every screenshot, and still missed roughly four in ten live-website tasks when researchers measured it outside the vendor's own benchmarks. Browserbase is not a rival to Playwright — it is where you run it when you need managed browsers, recordings and concurrency. The loser, for this job, is Claude Computer Use (or any screenshot agent) as the primary executor. Use it as the fallback.
| Playwright (self-hosted) | Browserbase (+ Stagehand) | Claude Computer Use | |
|---|---|---|---|
| What it is | Open-source browser-driving library, Apache-2.0 | Hosted headless browsers; Stagehand adds natural-language act() / extract() |
A model that reads screenshots and emits clicks and keystrokes |
| Price (checked 2026-09-23) | $0 licence; your compute | $20/mo (100 hrs) or $99/mo (500 hrs), then $0.12 / $0.10 per browser hour; Scale is "custom" | Tokens: Sonnet 5 at $2 / $10 per million input/output |
| Our workload, per month* | Your own container | ~$99-$116 plus proxy bandwidth if enabled | ~$1,300-$4,200 in tokens, before failures |
| Changed DOM | Role locators survive markup churn; a renamed label or new step breaks it — loudly | Script breaks the same way; act() can re-find the control |
Usually adapts to cosmetic changes; fails silently or wanders on flow changes |
| Credentials | A storageState file you must protect |
Contexts encrypted at rest on Browserbase | Vendor docs say keep login data away from the model |
| Who should NOT pick it | Teams with no engineer to fix a broken selector within a day | Teams whose portal data must never leave their VPC | Anyone running a known flow more than a few dozen times a day |
| Verdict | Default executor | Where to run it at scale | Fallback only |
*Workload defined below: a 12-step task, 10,000 runs a month.
What Are You Actually Choosing Between?
You are choosing between paying for a script once and paying a model on every run — the hosting question is secondary. Browser automation is software that drives a real browser the way a person would: load the page, find the control, click, read the result. The three options sit at different points on one axis.
A scripted flow is code that names each control in advance. Playwright, Microsoft's Apache-2.0 library, is the default here, with 96,500+ GitHub stars as of this writing. It drives Chromium, Firefox and WebKit, and it now ships an MCP server so an agent can call it as a tool.
A hosted browser platform runs those browsers for you. Browserbase's pricing page sells browser hours, concurrency, session recordings, proxies and captcha solving. Its open-source SDK, Stagehand (MIT, ~25,300 stars), lets you mix code with natural-language calls such as act("click the Download Invoice button").
A computer-use agent is a model that looks at a screenshot, decides what to do, and returns a mouse or keyboard action for your code to execute. Anthropic's current toolset is computer_toolset_20260801, generally available on the Claude API, and Anthropic has added a separate browser use toolset that reads the accessibility tree as well as pixels. In both cases, Anthropic's docs are explicit that "your application runs every call against its own browser automation; nothing runs on Anthropic's side." You still need somewhere to run the browser — which is why Browserbase shows up in agent stacks too.
Steel-man the agent case: the portal owner never promised you a stable UI, and a script is a contract with markup you do not control. That is true. It just doesn't change the arithmetic below.
What Breaks First When the Vendor Changes the DOM?
The script breaks first on a renamed button or an added step; the agent breaks first on everything else, and more often. Those are different failure modes, and only one of them tells you it happened.
Playwright's own guidance is to target what a user sees, not the markup. Its locator docs warn that "CSS and XPath selectors can be tied to the DOM structure or implementation. These selectors can break when the DOM structure changes," and recommend role locators such as getByRole('button', { name: 'Download' }) instead. Locators also re-resolve on every action, so a re-render between steps does not strand the script on a stale element. Written this way, a portal's CSS refactor usually passes straight through. What kills it is a changed label, a new interstitial, or a new MFA prompt — and when that happens the step times out and your job fails with a stack trace pointing at the exact line.
Agents shrug off the class rename. Their problem is the base rate. Online-Mind2Web, an Ohio State and UC Berkeley benchmark of 300 tasks on 136 live websites, found most frontier web agents succeeding around 30% of the time, with Claude Computer Use 3.7 at 56.3% and OpenAI's Operator at 61.3% — against near-90% claims on older benchmarks. That measurement is from 2025 and today's models are better; treat it as a warning about vendor-reported scores, not as today's number. Re-measure on your portal before you trust any figure, including ours.
The middle path is Stagehand's. Its README claims "act() self-heals when the site redesigns its form," and its docs describe caching a resolved action so repeat runs replay it without an LLM call. Two caveats. A self-healed click is a click the model chose, so it needs the same verification as any agent step. And the saving depends on the cache working: a February 2026 GitHub issue reported Browserbase's server-side cache returning MISS on every act(), extract() and observe() call in v3.1.0; the issue is now closed. Check your own cache-hit rate in the first week rather than assuming the discount.
What Does a Successful Task Actually Cost?
Price the successful task, not the run: at 10,000 runs a month, a scripted flow's model bill rounds to zero while a pure computer-use agent spends roughly $1,300-$4,200 in tokens and still hands you hundreds of failures.
The workload, so the numbers compare like for like: a 12-step portal task — log in, search a purchase order, open it, download the invoice PDF, read three fields — run about 500 times a business day, 10,000 runs a month. Prices checked 2026-09-23.
Playwright, self-hosted. No licence cost (Apache-2.0). At about a minute per run, that is ~167 browser-hours a month on whatever container you already pay for. The real cost is engineer time when the portal changes.
Playwright on Browserbase. The Startup plan is $99/month with 500 browser hours included, then $0.10 per browser hour, and 100 concurrent browsers. Scripted runs fit inside the allowance: $99/month. If agent-length sessions stretch each run to four minutes, that is ~667 hours and about $116. The line to watch is proxies: 5 GB included, then $10/GB. At an assumed 3 MB per run, turning proxies on adds ~30 GB and roughly $250 a month — more than the browsers. A portal you hold a customer login for rarely needs one.
Claude Computer Use as the executor. Anthropic's pricing page lists Claude Sonnet 5 at $2 per million input tokens and $10 per million output, and says declaring the computer-use toolset adds about 4,590 input tokens on Sonnet 5. The tool docs put each screenshot at "roughly 1,000–1,800 input tokens." Because every turn re-sends the conversation, a 12-step run accumulates. Our estimate, assuming ~1,500 tokens per screenshot and ~300 output tokens per step:
| Per 12-step attempt (Sonnet 5, our estimate) | Uncached | With prompt caching |
|---|---|---|
| Input tokens | ~190,000 → ~$0.38 | ~25k written at 1.25x, ~165k read at $0.20/M → ~$0.10 |
| Output tokens | ~3,600 → ~$0.04 | ~$0.04 |
| Per attempt | ~$0.42 | ~$0.13 |
| 10,000 attempts / month | ~$4,200 | ~$1,300 |
Now divide by the success rate. At 75% success, cost per successful task is $0.17-$0.56, and 2,500 runs a month land on a human's desk. At the 56% Online-Mind2Web measured, it is $0.23-$0.75 and 4,400 exceptions. Opus 5.5 at $4 / $20 per million roughly doubles every figure. OpenAI's route is in the same range: its pricing page lists GPT-5.4 at $2.50 input and $15 output per million.
The hybrid. Run the script; call the model only for the step whose locator times out. If 3% of runs fall back, that is ~300 agent attempts — ~$40-$130 a month — and every fallback is logged, so you know which selector to fix.
The ratio is the point: the pure agent costs about 30x the hybrid in tokens alone, before the exception queue.
Who Holds the Portal Password?
Keep the credential out of the model's context in all three designs — Playwright and Browserbase make that easy, and a screenshot agent makes it your job.
Playwright's authentication guide logs in once and saves a storageState file that later runs reuse. It is blunt about the risk: the file "may contain sensitive cookies and headers that could be used to impersonate you," and should never be committed. Put it in your secrets store, not the repo.
Browserbase's Contexts persist the Chromium profile between sessions and are "uniquely encrypted at rest." Two operational catches from the same page: concurrent sessions on one Context can trigger the portal to force a logout, and you must wait a few seconds after closing a persist: true session before reusing it. Stagehand's observe() returns real selectors "so credentials never reach the model" — your code types the password, not the LLM.
With Computer Use, Anthropic's own precautions list "avoiding giving the model access to sensitive data, such as account login information," a dedicated VM, a domain allowlist, and a human confirming "completing financial transactions, or agreeing to terms of service." Every one of those is on you. Log in with code, hand the agent an authenticated session, and treat anything it reads on the page as untrusted input — the same docs note Claude "will follow commands found in content even when they conflict with your instructions." For the identity layer behind this, see our agent identity comparison.
Will the Portal Block You — and Can It Sue?
Bot detection is a technical problem you can solve with signed identity; terms of service are a contract problem that no stealth mode solves.
The legal floor moved in August. The Ninth Circuit's opinion in Amazon v. Perplexity vacated Amazon's injunction, holding that the user accessed Amazon's computers, with the agent as a tool. Cooley's read flags what the ruling leaves open: contract and tort claims, and agents whose own systems talk directly to the site's servers. A headless browser in your cloud or on Browserbase is closer to that second pattern than Perplexity's user-side browser was. We covered where the ruling stops in Amazon's block of Meta's Muse agent.
For a vendor portal, you are a paying customer, which is your best position: read the portal's terms for an automated-access clause and get written permission from your account manager. That email is worth more than any feature on this page.
What not to do is evade. Captcha solving and stealth fingerprints — Browserbase sells both, with "Verified" browsers on the Scale plan — are defensible for public pages and a bad look against a supplier whose contract you signed. The better direction is identifying yourself: Cloudflare's verified bots, which absorbed signed agents on July 1, 2026, can prove identity with a cryptographic Web Bot Auth signature so site owners can allow an agent by policy instead of guessing from behaviour. Browserbase's Web Bot Auth support is in beta on request. Scale pricing is "custom" — we did not get a number.
Where Does a Scripted Playwright Flow Still Win Outright?
On every repeated, known, consequential flow — which is most vendor-portal work.
- Volume. Past a few dozen runs a day, per-run token cost dominates and a script's marginal cost is zero.
- Auditability. A script does the same thing every time; your auditor can read it. An agent's path differs per run.
- Consequential actions. Approving a payment, submitting a claim, accepting terms — Anthropic itself says a human should confirm these. A script can require that; an agent needs a gate in front of every step.
- Speed. A practitioner write-up on portal automation notes agent latency "tends to be measured in seconds or minutes, not milliseconds."
That same write-up makes the point that beats all three options: many portals call a JSON API behind the page. Open DevTools, watch the Network tab while you click through, and if the invoice arrives from /api/invoices/{id}, replay that request with the session cookie. No DOM, no screenshots. It is also the option most exposed to the terms-of-service question above, so get the permission first.
How Do You Decide Without Regretting It?
The criteria that predict regret are run volume, flow stability, and what a wrong click costs — not which demo looked smartest.
- Runs per day on the same path. Under ~20 and the flow changes weekly: an agent (or Stagehand
act()) is cheaper than an engineer maintaining selectors. Over ~100: script it. - Cost of a silent wrong answer. If a misread invoice total flows into payables, you need a failure that throws, not one that returns plausible data. Scripts throw.
- Where the browser may run. If portal data cannot leave your network, self-host Playwright; Browserbase runs the browser on its infrastructure.
- Concurrency and forensics. If you need 50 parallel sessions and a recording of every failed run, Browserbase buys you that for $99/month instead of a sprint.
- What changes the answer: a portal that redesigns constantly, a one-off migration you will run once, or a long tail of 200 different supplier portals each run weekly. That last case is where agents genuinely earn their token bill — no one will script 200 portals.
This Week: Click through the portal with DevTools open. Write down whether the data comes from a JSON call, and email your account manager for written permission to automate.
This Month: Write the Playwright flow with role locators only, store auth state in your secrets manager, and add a fallback that calls Computer Use or Stagehand act() on a locator timeout — logging every fallback.
Before Quarter Close: Report cost per successful task and fallback rate. If fallbacks exceed ~5%, fix the selectors rather than raising the agent budget.
The Bottom Line
This is the RPA cycle again, compressed. In the last one, teams bought recorders that promised to survive UI changes and spent years maintaining bots — Microsoft's computer-use GA was pitched as the end of that tax. The lesson carries: the intelligence belongs at the exception, not on the happy path. A model that re-reads the same login page 10,000 times a month is not automation; it is a very expensive way to avoid writing twelve lines of code.
Script what you know. Pay the model for what you don't.
Continue Reading
- Amazon Blocks Meta's Muse Agent Where the Perplexity Ruling Stops
- OpenAI Bought Macs. Your Pilot Bills 24 Hours Minimum.
- Microsoft Computer-Use GA: RPA's $100K Tax Just Ended
- Gemini 3.5 Flash Computer Use Threatens the $35B RPA Market
- NeMo Guardrails vs Guardrails AI vs Lakera: Buy the Detector
- Claude Opus 5.5 Rejects the Forced Tool Calls Opus 5 Accepted