TL;DR
- Playwright is the best starting point for repeatable navigation that a developer can describe in code.
- Browserbase is a strong managed home for those scripts when recordings, shared capacity and persistent contexts matter.
- Browser Use adds an agent that chooses browser actions, alongside a separately usable cloud browser service.
- Steel suits teams that want a managed sessions API with an open-source deployment path and explicit browser, proxy and CAPTCHA meters.
- Kernel is particularly useful for persistent profiles, managed authentication and workloads with substantial idle time.
For company research, start with a script over known URLs. Add an agent to handle unfamiliar navigation; buy managed browser infrastructure when operating the browsers becomes a recurring job. These are complementary layers, so Playwright on Browserbase or Browser Use on Kernel can be sensible combinations.
What you are actually buying
A browser framework opens pages and executes specified actions. An agent chooses actions from a goal and what it sees. A managed browser service supplies the runtime, connection endpoint, capacity and operational features. Buying the third does not automatically supply the second.
That distinction matters when a sales team asks for “an agent that researches 1,000 accounts.” Reading three known public pages is mostly retrieval and extraction. Finding a hidden careers page, changing a location filter and identifying a relevant opening adds navigation decisions. Logging into a licensed research system adds durable authentication and session ownership.
Keep the result contract the same across tools: matched company domain, source URLs, observed facts, retrieval time and a short account brief. A successfully closed browser session is not enough; the result must describe the right company and retain the supporting pages.
The five tools compared
| Tool | What it supplies | Best fit | Main trade-off | Current entry pricing basis |
|---|---|---|---|---|
| Playwright | Browser automation library and testing tools | Known navigation, reproducible selectors and developer-owned recovery | Your team runs the browsers and builds the agent loop if needed | No framework subscription; hosting, proxies and models are separate |
| Browserbase | Managed browsers compatible with established automation clients | Production scripts with recordings and persistent contexts | Browser capacity is separate from agent reasoning | Developer $20/month: 100 browser hours, 25 concurrent sessions, 1 GB proxy traffic |
| Browser Use | Open-source agent library, hosted agents and cloud browser infrastructure | Tasks requiring flexible navigation | Agent reasoning creates a separate model bill | Cloud browsers $0.02/hour; traffic and hosted model usage additional |
| Steel | Managed sessions API and open-source self-hosting path | Teams wanting explicit session and network meters | Multiple usage categories; self-hosting adds operating work | Launch $0 subscription plus usage: $0.10/hour and $10/GB proxy traffic |
| Kernel | Managed browsers, profiles and authentication features | Authenticated workflows and browsers that spend time waiting | Compute billing depends on browser mode and active runtime | Free plus usage with $5 monthly credits; Hobbyist $30/month with $10 usage credits |
Prices below use current official information accessed on 30 September 2026. They are buying bases, not measured throughput results.
1. Playwright: best for a workflow you can specify
Playwright supports Chromium, Firefox and WebKit and can run on local machines or CI. A developer can navigate to a careers page, choose a filter, wait for a visible result and extract role links without asking a model to rediscover those steps every time. Its trace viewer brings actions, DOM snapshots, screenshots, console output and network activity together for diagnosis. See the official introduction and trace viewer documentation.
Choose it when a small set of site patterns covers most accounts. It is also a good control layer underneath the managed products in this list. A stable script is easier to inspect than a free-form agent that may decide to explore ten extra pages.
The trade-off is operational ownership. Browser processes, concurrency, crashes, trace storage and network access still need a home. Playwright's authentication storage can reuse login state, but the application must manage its lifecycle. It does not turn a local script into a hosted research service. Authentication documentation.
2. Browserbase: best for hosting an existing automation workflow
Browserbase makes sense when the navigation code works and browser operations are consuming engineering time. Its Developer plan is $20 monthly with 100 browser hours and 25 concurrent sessions; additional hours cost $0.12 each. It includes 1 GB of proxy bandwidth, then charges $12/GB. Startup is $99 monthly with 500 hours, 100 concurrent sessions and 5 GB of proxy bandwidth, with $0.10/hour and $10/GB overages. Browserbase pricing.
Persistent contexts let later sessions reuse cookies and stored browser data. Fresh sessions are isolated by default; attach the intended context deliberately for a returning workflow. That is useful for a licensed research portal or a recurring company watchlist. Contexts documentation.
Choose Browserbase for managed runtime and debugging around your script or agent. Its pricing also lists native agent-run allowances, but those are a different product meter from running your own Playwright account jobs. Do not treat 15 included native agent runs as a limit of 15 scripted browser sessions, or assume the browser subscription includes all model reasoning.
3. Browser Use: best when navigation needs an agent
Browser Use offers two cloud paths: submit a task to its hosted agent, or create a cloud browser and connect your own Playwright or Puppeteer code over CDP. The open-source library is another option for operating the agent yourself. This gives a team a direct route from “find this company's relevant engineering vacancies” to an agent-controlled browsing task. Cloud quick start.
The cloud pricing is pay as you go. Browser runtime is $0.02/hour, rounded up to whole minutes with a one-minute minimum. Residential proxy traffic, enabled by default, is $5/GB; direct or custom-proxy traffic is $0.20/GB, with any external proxy provider's fees separate. Hosted agent model billing adds 20%; the published V4 model table already incorporates that markup. The default shared concurrency limit is 10. Browser Use pricing.
Choose it for variable layouts and discovery that would require many brittle scripts. For three known pages, its cloud browser can still run deterministic code without the hosted agent. The main non-fit is an unconstrained research brief: additional navigation decisions can increase pages, model calls and time without improving the account recommendation. Specify the pages and evidence the result needs.
4. Steel: best for an explicit sessions and network budget
Steel supports familiar automation clients and provides an open-source deployment path. Its current Launch plan has no monthly subscription, 10 concurrent sessions and a 15-minute session ceiling. Browser runtime is $0.10/hour, proxy traffic $10/GB and CAPTCHA solves $3 per 1,000. Browser time rounds up by the minute. Launch's $30 credit is one time and expires after 90 days. A $10 paid deposit enables Steel-provided proxies or CAPTCHA solving and becomes usable balance rather than an extra fee. Steel pricing and limits.
Scale is $250 monthly with $100 monthly usage credit, 100 concurrent sessions and a one-hour session ceiling. Its browser and proxy rates are $0.08/hour and $6/GB. The June 2026 pricing change left existing legacy customers on their old plans until they switch; a new buyer should use the current Launch and Scale terms. Pricing announcement.
Choose Steel when you want to connect your own agent or script and understand which network and browser activities drive the bill. Self-hosting is useful where runtime control justifies maintenance. It is not a zero-cost replacement for the cloud service: someone still owns deployment and incidents. For small jobs, buying Scale purely for lower unit rates rarely makes sense.
5. Kernel: best for profiles, authentication and idle-heavy work
Kernel combines browsers with persistent profiles, live views, replays and managed authentication. A profile preserves cookies, site data, tabs and preferences. Browsers load a snapshot; changes persist when save_changes is enabled and the Kernel browser is deleted or times out. Merely disconnecting Playwright does not save that profile. For parallel readers, load the shared starting profile without saving changes; nominate one writer when state must persist. Profile documentation.
Kernel publishes a $0.0000166667 per GB-second compute basis. Its current detailed rates are $0.0000166667/second for headless browsers and $0.0001333336/second for headful browsers. Idle browsers enter standby after five seconds without CDP or Live View activity and stop accruing runtime charges. Proxies have no additional charge. Free offers five concurrent browsers and one-day replays; Hobbyist costs $30 monthly, offers 10 concurrent browsers and seven-day replays, and includes $10 in monthly usage credits. Pricing and billing details.
Choose Kernel when reusable login state or waiting between actions is central to the workflow. Browser mode matters to the price, and agent code deployed as Kernel app invocations has its own compute meter. The browser rate alone is not an all-in agent price.
A concrete account-research run
Consider a fictional job for northstar.example. The input contains the company domain, its careers URL and a product page. The output should answer whether the company sells enterprise software and has a relevant open role, supported by page URLs and short excerpts.
- Open the supplied company URL and confirm the domain before following links.
- Read the product page. Store the enterprise positioning evidence rather than inferring company size from a logo strip.
- Open careers. If the page is a rendered job board, wait for the result list and apply the requested location filter.
- Follow at most two relevant role links. Record the job title and stated location; leave an unstated posting date blank.
- Produce the brief, save the evidence and close the managed browser through its provider API.
Use Playwright for steps you can describe reliably. Let an agent handle the unfamiliar careers navigation, with a page and time budget. Browserbase, Steel or Kernel can host that browser; Browser Use can supply both the browser and the decision loop.
If a role link fails, retry that page once while retaining the product evidence. If the domain belongs to another company, reject the match. If a login expires, resume from the affected step after authentication rather than repeating all successful retrieval. Nothing in this research task requires the agent to submit a form, send a message or edit a CRM record.
The signal-based outbound playbook explains how to turn those observed facts into a useful account priority and message angle.
What 1,000 account jobs cost
Use an illustrative monthly workload: 1,000 jobs at three browser minutes each, plus 100 one-minute retries. That is 3,100 billed minutes, or 51.67 browser hours, with 2 GB of proxy traffic. These are planning assumptions, not a vendor benchmark. Assume $20 of direct model usage for the same reasoning workload, separate from browser costs.
| Option | Browser and traffic calculation | Workload budget before models and labour |
|---|---|---|
| Playwright on your own host | Assume $40 for the host; proxy services priced separately | $40 hosting assumption plus traffic |
| Browserbase Developer | $20 includes the hours and 1 GB; the extra 1 GB is $12 | $32 |
| Browser Use cloud browser | 51.67 × $0.02 + 2 × $5 residential proxy | About $11.03 |
| Steel Launch | 51.67 × $0.10 + 2 × $10 | About $25.17 before the one-time credit |
| Kernel, headless | Assume all 3,100 minutes remain active: 186,000 seconds × $0.0000166667 | About $3.10 usage, covered by the Free plan's $5 monthly credit |
Whole-minute rounding is already reflected in the first workload. Browser Use's direct-traffic alternative would be about $1.43 instead of $11.03 for the stated volume, but it is a different network configuration, not a promise of equivalent access to every target site.
For Kernel, the same active time in headful mode costs about $24.80 before credits. Hobbyist would therefore be $30 + ($24.80 − $10) = $44.80, with seven-day replays and 10 concurrent browsers. Standby can reduce active seconds; this table conservatively assumes continuous activity. Kernel-hosted app execution is outside these browser-only figures.
Add the assumed $20 model bill when your own agent calls its provider directly: Browserbase becomes $52 and Steel about $45.17. For Browser Use's hosted agent, a $20 underlying model bill with its 20% markup becomes $24, making the illustrative hosted browser, traffic and model total about $35.03. A deterministic script may need substantially less model usage; an exploratory agent may need more. The assumption is held constant to expose the infrastructure difference.
Labour can dwarf that difference. Suppose 100 account briefs need three minutes of review: five hours at $50/hour adds $250. Browserbase plus the model assumption then costs $302; if 900 briefs are usable, that is approximately $0.34 per usable brief before setup. Avoiding 50 unnecessary reviews saves $125, more than the monthly browser bill in this scenario. Optimise matching and evidence quality before chasing a few cents of runtime.
Recovery and persistent sessions
Give each account job a run ID and save completed steps outside the browser. Record the source URL, output and rejection reason. A stored cookie restores a session; it does not prove which research steps finished.
Keep a trace or replay for failed jobs, especially a blank extraction from a page that looked loaded. Playwright's trace is useful for selector and network failures. Managed recordings help diagnose a remote session without recreating it locally. Retention is a buying consideration: a one-day replay is less useful for a weekly review than a seven-day one.
Close provider sessions explicitly when the job finishes. Browser Use documents that disconnecting CDP does not stop its cloud browser. Kernel's profile save similarly depends on the browser lifecycle. Put cleanup in the failure path as well as the happy path. Limit retries so an unavailable page cannot consume the account's whole research budget.
Which tool to choose
For a developer-owned public account-research workflow, start with Playwright, then use Browserbase if remote debugging and managed capacity justify the subscription. That combination provides control without forcing a model to choose every click.
Choose Browser Use when the difficult part is deciding how to navigate unfamiliar pages. Its inexpensive cloud browser is also worth considering for your own scripts, but account for traffic and agent model billing separately.
Choose Steel when its session API, open-source path and explicit usage meters match your deployment preferences. Use Launch for modest workloads; Scale buys capacity and support as well as cheaper units.
Choose Kernel for authenticated, persistent or idle-heavy browser work. The Free plan is a reasonable small headless starting point; pay for Hobbyist when concurrency, authentication connections or replay retention requires it. Do not select a browser solely from a compute-only price while leaving the operating workflow out of the decision.
FAQ
Does a managed browser replace Playwright?
Usually it supplies the browser that Playwright controls. You can retain the navigation code and change where the browser runs. An agent is another layer that can choose actions instead of executing only predetermined steps.
Which option is cheapest?
Browser Use has a low published browser-hour rate, while Kernel can be inexpensive for headless work and does not add proxy fees. Actual cost depends on traffic, browser mode, activity, model reasoning and plan requirements. For repeatable navigation, removing unnecessary agent decisions can save more than switching hosts.
Should every company get a persistent browser profile?
No. Public research often benefits from a fresh session. Use persistent state for workflows that need it, such as a returning authenticated user. Keep parallel readers from overwriting the shared profile and retain completed job evidence outside that profile.
