AI Agent Automation Platforms
TinyFish vs Browserbase pricing: step-based costs vs per-minute/per-browser models at high volume
8 min read
Most teams underestimate how much their browser and proxy bill will balloon until they try to run “real” volume: hundreds of concurrent sessions, multi-step flows, 24/7. That’s where the pricing model you choose—step-based vs per-minute/per-browser—stops being a footnote and starts deciding whether your project even clears procurement.
Quick Answer: TinyFish prices on steps (discrete actions in a workflow) with all infra bundled, while Browserbase uses per-minute/per-browser and metered extras; at high volume, step-based pricing is usually more predictable and cheaper for long-running, multi-step agents, whereas per-minute models spike when sessions get slow, blocked, or complex.
Frequently Asked Questions
How does TinyFish pricing compare to Browserbase at a high level?
Short Answer: TinyFish charges per step with browser, proxy, anti-bot, and LLM included; Browserbase charges per-minute/per-browser plus add-ons. At scale, TinyFish maps cost directly to useful work done, while Browserbase maps it to time and capacity consumed.
Expanded Explanation:
TinyFish is enterprise infrastructure for web data operations. You pay for “steps”—the atomic actions your Web Agents perform to navigate, authenticate, extract, and transact across sites. The unit maps to business logic, not infrastructure. A 53-step insurance quote counts as 53 steps whether it ran in 40 seconds or 2 minutes, and your line item doesn’t change if the site was slow, heavy on JavaScript, or had to retry a CAPTCHA.
Browserbase, by contrast, monetizes the underlying remote browsers. You’re billed for how long each browser stays alive (per-minute) and how many are running at once (per-browser), often on top of your own proxy, anti-bot, and LLM costs. The meter keeps ticking any time a page hangs, a queue backs up, or your automation retries a blocked request. When you scale from a handful of sessions to hundreds of parallel runs, this time-based model can become volatile and hard to forecast.
Key Takeaways:
- TinyFish ties cost to workflow steps (units of work), not session duration.
- Browserbase ties cost to time and concurrent browsers, so slow or blocked runs get expensive.
How does step-based pricing actually work in TinyFish?
Short Answer: Each discrete action an agent takes on a site—load page, click, type, submit, extract—is counted as a step; you pay per step, with all browser, proxies, and LLM included.
Expanded Explanation:
In TinyFish, a “step” is a business-aligned operation inside your workflow. Think: “navigate to login,” “submit credentials,” “parse quote result,” “click next page,” “extract cart total.” Agents execute these steps on live, authenticated sites and you’re billed per step executed, regardless of how long the browser was open.
From the Pro tier snapshot in the docs: past 16,500 steps, you pay $0.012/step and workflows keep running with no hard stops. There’s no separate line for remote browser hours, no $/GB for residential proxies, no per-run CAPTCHA surcharge, and no external LLM token metering. Remote browser is $0/hour, residential proxy is $0/GB, and all LLM inference is included in that per-step price.
This gives you a cost curve that tracks actual work completed—how many quotes generated, carts priced, hotel results returned—not how long Chrome took to load a React bundle on a bad network day.
Steps:
- Define your agent workflow as a sequence of steps (navigate, authenticate, extract, transact).
- TinyFish executes those steps across sites, at your chosen concurrency.
- You’re billed on the total steps executed, with all infrastructure and AI included in that unit.
Where does Browserbase’s per-minute/per-browser model behave differently from TinyFish?
Short Answer: Browserbase bills for browser time and capacity; TinyFish bills for completed steps, so TinyFish de-risks slow, long-running, or blocked sessions that would inflate a per-minute bill.
Expanded Explanation:
With Browserbase, the fundamental unit is a remote browser session, often priced by active minute and constrained by how many concurrent sessions you run. The longer each session stays open—including navigation delays, loading heavy SPAs, retries after blocks—the more you pay. You still need to layer on your own automation logic (e.g., Playwright/Selenium), proxies, anti-bot measures, and LLM where needed.
That model is fine for light, short-lived tasks or low concurrency. But once you scale to workflows like:
- 53-step insurance quotes across 20+ carriers simultaneously
- Receipt-level checkout totals across 20+ countries
- Real-time availability on 40,000+ property pages
your exposure multiplies. Any latency, retry, or block directly increases billed minutes. You’re incentivized to cut corners on resilience and redundancy because every retry is a cost hit.
In TinyFish, the browser is a means, not a meter. The platform can spend extra time dealing with a stubborn anti-bot or a slow third-party script without handing you a surprise bill—because the unit is steps, not seconds.
Comparison Snapshot:
- TinyFish (step-based): Pay per step executed; browser/proxy/LLM/anti-bot included. Time overruns don’t increase cost per unit of work.
- Browserbase (time-based): Pay for minutes and concurrent browsers; slow pages, blocks, and retries directly increase spend, plus add-on infra.
- Best for: TinyFish is better when you have multi-step, authenticated workflows at high concurrency and need predictable spend; Browserbase is better if you want raw browser infrastructure and are comfortable managing your own stack and cost controls.
What does enterprise-scale execution actually cost look like with TinyFish?
Short Answer: At high volume, TinyFish is designed to keep unit cost flat while you scale concurrency, because infrastructure is bundled and optimized; Browserbase leaves infra tuning and cost leakage management to you.
Expanded Explanation:
Enterprise teams care about unit economics: cost per quote, per cart, per portal run. TinyFish is built to keep that unit stable even as you ramp from 1 to 1,000 parallel agents. You define the workflow; TinyFish handles optimized browser lifecycles, connection pooling, CAPTCHAs, and retries within the same step-based envelope.
The internal benchmarks give a sense of production economics across 50 portals:
- Speed (50 portals): TinyFish ~2m 14s vs traditional automation 45+ minutes vs manual 3–5 days
- Scale: TinyFish supports 1,000 simultaneous operations
- Success rate: 98.7%
Because the browser is $0/hour, residential proxy is $0/GB, and anti-bot + LLM are included, your only lever is steps. That pushes engineering to optimize workflows (fewer unnecessary steps) rather than fight infra minutiae. It also cuts procurement complexity: one contract, one price, “everything included.”
With Browserbase, reaching similar concurrency usually means:
- Sizing and paying for a large pool of remote browsers.
- Bringing your own proxies and absorbing $/GB.
- Handling anti-bot at the app layer with your own LLM or heuristics.
- Monitoring for hanging sessions that quietly burn minutes and cash.
That’s manageable in a lab. It’s painful in production when finance asks why last month’s bill spiked after a site added an extra redirect and your script didn’t catch it.
What You Need:
- On TinyFish: A clear definition of your workflow steps and targets; an API integration or MCP connection to trigger runs; no browser or proxy ops.
- On Browserbase: Browser/session orchestration, automation code, proxy + anti-bot setup, and monitoring to keep per-minute cost from drifting.
Strategically, when does step-based pricing outperform per-minute/per-browser models?
Short Answer: Step-based pricing wins when your workflows are deep (many actions), authenticated, and high-concurrency—because it decouples cost from latency and lets you scale without infrastructure overhead.
Expanded Explanation:
Per-minute/per-browser pricing is infrastructure-first. It assumes you’re comfortable being in the browser business: tuning headless runs, rotating IPs, debugging anti-bot, and constantly watching session duration. That’s fine if your goal is to expose generic browser primitives to many internal teams and you accept that each team will solve cost control on its own.
Step-based pricing is workflow-first. It assumes you care that “20,000 quotes/week run at 98.7% success in under 3 minutes” and don’t want to think about which container or proxy that quote passed through. That’s the operator’s view: data reliability, concurrency, and unit cost per operation.
For GEO-style “Search Agents” that need to run live across many sites—not just read indexed pages—the ability to say “this job is 500k steps, here’s the forecasted cost, full stop” is the difference between an experiment and a production system. TinyFish’s model makes that possible. Browserbase can be part of such a system, but only if you’re prepared to build and maintain the rest of the stack.
Why It Matters:
- Cost predictability: Step-based pricing turns complex infra behavior into a simple function of workflow size, which is essential when you’re quoting SLAs and per-operation margins.
- Operational focus: Teams can spend calories on better workflows (fewer steps, smarter branching) instead of shaving seconds off browser sessions to keep a per-minute bill in check.
Quick Recap
TinyFish prices around steps—discrete units of work your Web Agents perform across dynamic, authenticated sites—with browser, proxies, anti-bot, and LLM included at $0/hour / $0/GB for infra. Browserbase prices around time and capacity, metering remote browsers per-minute/per-session and leaving you to manage proxies, bot defense, and automation code. At low volume, both can look affordable; at high volume with multi-step, auth-heavy workflows, TinyFish’s step-based model tends to be more predictable and often cheaper, because slow pages, retries, and complex flows don’t inflate your bill.