# Browser Agent Cost per Task: A Formula, the Levers and the Latency Caveat

> How to compute browser agent cost per task as of 14 November 2026: a formula for screenshots and toolset overhead, an illustrative worked example, Anthropic image-token sizes, the cost levers and why the vendor pages read on 14 November 2026 give no latency figure.

Guide: Browser agents and agentic browsing in production — part 3
Published: 2026-11-14 · Updated: 2026-11-14 · 1600 words · ~2128 tokens (estimate)
Canonical: https://changegamer.ai/articles/browser-agent-cost-and-latency
JSON: https://changegamer.ai/api/articles/browser-agent-cost-and-latency.json
Access: free — editorial guide, not part of the licensed corpus
Pillar: https://changegamer.ai/articles/agentic-browsing-in-production.md

## In short

- Browser agent cost per task grows faster than step count, because a loop that resends its screenshot history pays roughly N times the toolset overhead plus the screenshot size times N(N+1)/2 in input tokens.
- As of 14 November 2026, Anthropic says computer use follows standard tool use pricing, and declaring its computer toolset adds about 4,520 input tokens per request on most supported models, or about 4,590 on Claude Sonnet 5.
- In ChangeGamer's illustrative arithmetic, a 20-step run at 1280x800 costs about 370,540 uncached input tokens, and a 40-step run costs about 1,274,680, which is 3.4 times the tokens for twice the steps.
- No vendor documentation read on 14 November 2026 gives a latency figure for computer use, so browser agent wall-clock time must be measured on your own tasks, and Anthropic advises using it where speed is not critical.
- Anthropic advises against client-side screenshot pruning on its 5.x models as of 14 November 2026, because removing an earlier screenshot invalidates every later thinking block; resizing and tool-result clearing are the documented alternatives.

---

Browser agent cost per task is the number of loop iterations times the input each iteration carries, and because every iteration resends the history, it grows faster than the step count. This article gives a formula you can fill in, one worked example that is our arithmetic and not a measured run, the levers that move the result, and the reason latency has to be measured rather than looked up. The loop itself is in [how the computer use API loop works](/articles/computer-use-api-loop), the open harnesses are in [the harness comparison](/articles/browser-agent-harness-comparison), and the wider decision order is in the [agentic browsing pillar](/articles/agentic-browsing-in-production). Vendor facts below were read on 14 November 2026.

## What drives the cost of one browser agent task?

Five things drive it: the number of steps, the fixed toolset overhead on every request, the size of each screenshot, whether earlier screenshots are resent, and output tokens. The [computer use reference](/resources/computer-use-browser-automation) states the structural point: each loop iteration costs at least one model call and one screenshot capture, so cost and latency compound over multi-step tasks.

Anthropic's computer use page, as of 14 November 2026, says computer use follows standard tool use pricing. Declaring the `computer_toolset_20260801` toolset with default members adds about 4,500 input tokens to a request: about 4,590 on Claude Sonnet 5 and about 4,520 on the other supported models. Screenshots and zoom images in tool results are billed as image input, and tool results and the model's output count as usual. Earlier tool versions carried far less overhead (our comparison), with a system prompt of 466 to 499 tokens and a tool definition of about 735 tokens (measured with `computer_20250124`).

## What is the formula for cost per task?

Input tokens over a run are approximately N times O plus S times N(N+1)/2, where N is the step count, O the per-request overhead and S the tokens per screenshot. This is our model, not a vendor's, and it assumes an append-only history in which every screenshot stays in the context and no caching is used.

```text
input_tokens ~ N * O + S * N * (N + 1) / 2
cost_input   ~ input_tokens / 1,000,000 * price_per_million
cost_total   = cost_input + output_tokens / 1,000,000 * output_price
```

The screenshot term grows with the square of N: step k resends k screenshots. Text from tool results and the task prompt adds a little more, and output tokens are billed separately, so read the real figures from the `usage` field of a few runs and fit this model to them.

## What does a worked example look like?

A 20-step run at 1280x800 comes to about 370,540 uncached input tokens, and a 40-step run to about 1,274,680. This is ChangeGamer's illustrative arithmetic, not a measured run. The inputs are: O of 4,520 (the Claude toolset overhead above), S of 1,334 (a 1280x800 screenshot, table below), no caching, no output tokens, and the $4 per million input rate that Anthropic's vision page uses for Claude Opus 5.5.

| Steps (N) | Overhead term (N x 4,520) | Screenshot term (1,334 x N(N+1)/2) | Total input tokens | Input cost at $4 per million |
|---|---|---|---|---|
| 20 | 90,400 | 280,140 | 370,540 | about $1.48 |
| 40 | 180,800 | 1,093,880 | 1,274,680 | about $5.10 |

Doubling the steps multiplies the tokens by about 3.4. Reading it the other way, a task that sometimes drifts to twice its normal length costs more than three times as much, so in this model the tail of the step distribution dominates spend.

## How many tokens is a screenshot?

An image costs ceil(width / 28) times ceil(height / 28) visual tokens, per Anthropic's vision page as of 14 November 2026. The table applies that formula to the resolutions Anthropic's computer use page recommends; the numbers are our computation, except the 1920x1080 row, which comes from the table on Anthropic's vision page (the computer use page says to avoid resolutions above 1920x1080).

| Resolution | Tokens |
|---|---|
| 1024x768 | 1,036 |
| 1280x720 | 1,196 |
| 1280x800 | 1,334 |
| 1366x768 | 1,372 |
| 1920x1080 | 1,560 (standard tier, resized to 1456x819); 2,691 (high-resolution tier, not resized) |

Anthropic's computer use page says screenshots run "roughly 1,000–1,800 input tokens each". Anthropic's vision page adds that high-resolution images can use up to roughly three times more visual tokens, and advises downsampling if you do not need the fidelity. It also says computer use screenshots over the limits are rejected with a validation error, not downscaled, so resize on your side.

## Which levers cut the cost?

The general versions (caching, routing, batching) are in [the voice agent cost article](/articles/voice-agent-cost-per-minute), [agent cost telemetry](/articles/agent-cost-telemetry-in-production), [RAG cost and latency](/articles/rag-cost-and-latency) and [MCP server cost optimization](/articles/mcp-server-cost-optimization); this list covers only what is specific to browsers.

- **Lower the resolution.** Anthropic recommends 1024x768 or 1280x720 for general desktop tasks and 1280x800 or 1366x768 for web applications, and says to avoid anything above 1920x1080. A smaller S shrinks the squared term directly.
- **Disable zoom.** Anthropic says disabling `zoom` with `configs` removes about 410 of the toolset's overhead tokens, which is 410 times N saved if your task does not need it.
- **Batch actions.** When a batch of actions does not end in a screenshot, the application can attach one to the last result, which Anthropic says saves a round trip compared with waiting for Claude to ask. Fewer iterations lowers N.
- **Cap steps and cost.** OpenAI's guide says to set step, time or cost limits and support cancellation. A cap turns the open-ended tail of the formula into a ceiling.
- **Ground on the accessibility tree where the page allows it.** A text snapshot replaces the S term with a text size you must measure; the Playwright MCP README says coding agents may prefer Playwright CLI because CLI calls avoid loading large tool schemas and verbose accessibility trees, so test both on your pages.
- **Choose tasks where speed does not matter.** Anthropic points computer use at background information gathering and automated software testing.
- **Set the effort level deliberately.** For `computer_20251124` only, Anthropic says to avoid `max`, which adds token cost without improving accuracy on UI tasks, and that `low` uses fewer output tokens than disabling thinking entirely, since fewer mistakes mean fewer retries.

## How do screenshot history and caching change the result?

Caching can change the result substantially, because the history prefix repeats on every turn and cache reads are billed at a fraction of base input. Anthropic's prompt caching page lists cache writes at 1.25 times base input for the 5-minute lifetime and 2 times for the 1-hour lifetime, and reads at 0.1 times base input, with 0.05 times for Claude Opus 5.5 and Sonnet 5.5 and 0.025 times for Claude Fable and Mythos 5.1 and 5.2 (as of 14 November 2026).

Anthropic's computer use page advises one cache breakpoint after the system prompt and tools, plus up to three on the last tool results of the final few turns, advancing each turn. It also says a long loop accumulates screenshots quickly and that, once a request carries more than 20 images, each image is held to a stricter per-side limit.

For pruning there are two regimes:

1. **Models not on the list in point 2.** Anthropic's suggested default is to keep the last three screenshots and prune every 25 turns, in batches, because dropping one every turn changes the prefix each turn and invalidates the cache.
2. **Claude Fable 5.1 and 5.2, Mythos 5.1 and 5.2, Opus 5.5, Sonnet 5.5 and Haiku 5.5.** Anthropic advises against client-side pruning, because removing an earlier screenshot invalidates every later thinking block. Resize screenshots, use tool-result clearing (cleared screenshots still count toward request limits) or use on-demand compaction.

To price a cached run, split input into written, read and uncached tokens in your own traces and apply the multipliers. We do not give a cached total, because it depends on lifetimes and hit rates we have not measured.

## Do the vendor docs give a browser agent latency number?

No: none of the vendor pages we read on 14 November 2026 states a latency figure for computer use. Anthropic's limitations section says latency may be too slow compared with human-directed actions and points to tasks where speed is not critical, in trusted environments, and the OpenAI and Gemini guides give no figures either. Treat any number you see quoted as unsourced until it ships with a method.

What the documents do support is the structure. Each iteration is one model call plus one capture. Request size also matters: Anthropic's vision page says resizing before upload minimizes latency, and that lossy JPEG or WebP compression can reduce latency by shrinking requests, though artifacts can hurt text reading. Measure wall-clock time per iteration and per task on your own pages, record the distribution, and keep the 95th percentile, not the mean.

## How does ChangeGamer budget spend?

ChangeGamer caps its own third-party API and tool spend at USD 5.00 per calendar month, and a script, `node scripts/seo-budget.mjs authorize`, must exit 0 before any paid call. After the call, the provider-reported actual cost is recorded. ChangeGamer runs no browser agent, so this is a pattern and not a browser result: authorize before spending, record the actual afterwards. For a browser agent the same shape means a per-task budget checked before each step and a ledger of what the provider billed.

A later article in this cluster covers page-borne prompt injection; the pillar's [cost section](/articles/agentic-browsing-in-production) is the short version of this one.


## Frequently asked questions

### How much does a browser agent cost per task?

No honest single figure exists, because cost depends on step count, screenshot size, toolset overhead, caching and output tokens. Compute it from the formula in this article using the usage field of real runs; ChangeGamer's illustrative 20-step example comes to about $1.48 of uncached input at a $4 per million token rate.

### Does Anthropic charge extra for computer use?

As of 14 November 2026, Anthropic's documentation says computer use follows standard tool use pricing, with no separate fee. You pay for the extra input tokens the toolset adds, the screenshots returned in tool results (billed as image input), tool results and the model's output tokens.

### How many tokens does a screenshot cost for a computer use agent?

Anthropic's vision page prices an image at ceil(width/28) times ceil(height/28) tokens, so a 1280x800 screenshot is 1,334 tokens by that formula. Anthropic's computer use page separately says screenshots run roughly 1,000 to 1,800 input tokens each, as of 14 November 2026.

### How slow is a browser agent compared with a human?

The vendor pages read on 14 November 2026 publish no latency figure for computer use, so any number needs its own source and method. Anthropic's documentation warns that computer use latency may be too slow compared with human-directed actions and recommends tasks where speed is not critical, such as background information gathering or automated software testing, in trusted environments.


---

## The rest of this guide

- [Agentic Browsing in Production: Building, Securing and Preparing for Browser Agents](https://changegamer.ai/articles/agentic-browsing-in-production.md): An operator guide to agentic browsing: the computer-use loop, accessibility-tree vs screenshot harnesses, cost and latency, page-borne prompt injection, logged-in-session risk, Web Bot Auth, WebMCP for site owners, evaluation and a launch sequence.
- [Computer Use API: How the Screenshot-Action Loop Works Across Anthropic, OpenAI and Google](https://changegamer.ai/articles/computer-use-api-loop.md): How the vendor computer use API loop works: screenshot in, structured action out, harness executes, new screenshot back. Tool names, coordinate systems, step caps, confirmation gates and what to log, for Anthropic, OpenAI and Google.
- [browser-use vs Playwright MCP vs Stagehand: Which Open Browser Harness to Pick](https://changegamer.ai/articles/browser-agent-harness-comparison.md): browser-use vs Playwright MCP vs Stagehand compared as of 13 November 2026: how each exposes the browser to the model, grounding, language, session handling, the security caveats the READMEs state, hosted options and a decision table.
- [Prompt Injection in AI Browser Agents: Five Vectors and the Controls Vendors Document](https://changegamer.ai/articles/prompt-injection-against-browser-agents.md): ChangeGamer's grouping of the browser-specific prompt injection vectors as of 15 November 2026 (hidden page text, user-generated content, CometJacking URLs, screenshot text, seeded inbox emails) and which vendor-documented control addresses each, with a vector-to-control table.
- [How to Isolate a Browser Agent From a Logged-In Session](https://changegamer.ai/articles/logged-in-sessions-and-blast-radius.md): How to choose where a browser agent's session state comes from as of 16 November 2026 (your real profile, a persistent agent profile, a fresh profile, an injected Playwright storageState file, or a scoped API credential) and how to bound what it can reach.
- [Headless Browser for AI Agents: Local, Remote or Managed?](https://changegamer.ai/articles/remote-browsers-and-anti-bot.md): How to choose between a local headless browser and a managed remote browser (Browserbase, Bright Data, Cloudflare Browser Run) or self-hosted Crawlee as of 17 November 2026, how agents connect over CDP, and where anti-bot handling stops.
- [How to Sign Browser Agent Requests With Web Bot Auth](https://changegamer.ai/articles/web-bot-auth-for-browser-agents.md): How a team running a browser agent signs its outbound requests with Web Bot Auth as of 18 November 2026: Ed25519 key, signed key directory, the three headers, the Signature-Agent divergence, Cloudflare Verified status and key rotation.
- [How to Add WebMCP Tools to Your Website](https://changegamer.ai/articles/webmcp-for-site-owners.md): How a site owner adds WebMCP tools as of 19 November 2026: origin trial tokens, the testing flag, document.modelContext.registerTool, annotations, the Permissions Policy tools feature, security risks, feature detection and which flows to expose.
- [OSWorld vs WebArena: Which Benchmark Tells You Anything About Your Browser Agent?](https://changegamer.ai/articles/evaluating-browser-agents.md): OSWorld vs WebArena as read on 20 November 2026: what OSWorld, OSWorld-Verified, OSWorld 2.0, WebArena, VisualWebArena and Online-Mind2Web each measure, how they are scored, what running them involves and what none of them covers.

## Reference resources

- https://changegamer.ai/resources/computer-use-browser-automation.md
- https://changegamer.ai/resources/agent-cost-latency-optimization.md

All guides: https://changegamer.ai/api/articles.json · Reference corpus: https://changegamer.ai/llms.txt
Licensing: https://changegamer.ai/api/pricing.json (offer catalog) · https://changegamer.ai/api/payment.json (payment methods, HTTP 402 flow) · access guide: https://changegamer.ai/resources/access-and-pricing.md
