Ten public pricing pages. Eight minutes forty-four seconds. Thirty-nine model requests. The gateway statement: $0.4273, or 4.3 cents a page.
The same ten pages through OpenCode's built-in webfetch tool cost $0.4684 and read eight of them. That is the counterintuitive part. The browser path did more work and cost less, because the bill follows fresh input tokens, not page views.
Disclosure: Wallaby sells API access to Kimi K3.1 Pro. Both runs used our endpoint, our test key, and our gateway statement. We did not compare vendors here; we compared two ways of reading the same pages with the same model.
What Browse actually does
OpenCode Browse is an MCP server plus a Chromium extension. It lets an agent use the browser you are already signed into: it opens background tabs, reads the DOM, clicks, types, takes screenshots, and records tabs. When a site needs a login, a 2FA prompt or a payment, the tab is handed back to you and the agent continues after you click Continue. It works with any MCP client, not only OpenCode.
The extension version in this run was 0.1.5, released on 17 November. The client was OpenCode 1.19.5.
The run
We gave it one task: open ten public pricing pages, read each one, and return a single table of input and output prices. The pages were OpenRouter, Anthropic, Google Gemini, DeepSeek, Moonshot, Mistral, Groq, Together, Fireworks and DeepInfra.
The browser ran in a separate Chrome for Testing 136 profile with no logins, so no account data was involved. The task used 14 navigations for 10 pages, three DOM snapshots, 18 JavaScript evaluations, two screenshots, one click and two tab-list calls. The extra navigations were retries: Groq's pricing URL redirected to a marketing page, and the agent walked through four documentation URLs before finding the prices on the models page.
| Browse run | Value |
|---|---|
| Wall time | 8 min 44 s |
| Model requests | 39 |
| Pages read | 10 of 10 |
| Prompt tokens | 1,145,391 |
| Fresh input tokens | 108,130 |
| Cached input tokens | 1,037,261 |
| Output tokens | 5,109 |
| Gateway bill | $0.4273 |
The webfetch arm used the same prompt and the same model. It made 10 webfetch calls, finished in 2 min 23 s, and read eight pages. Moonshot's pricing tables are rendered by JavaScript and came back empty; Groq's pricing page returned marketing text with no prices.
| webfetch run | Value |
|---|---|
| Wall time | 2 min 23 s |
| Model requests | 12 |
| Pages read | 8 of 10 |
| Prompt tokens | 513,220 |
| Cached input tokens | 292,096 |
| Output tokens | 1,983 |
| Gateway bill | $0.4684 |
The bill checks out
Wallaby's rates for Kimi K3.1 Pro are $1.80 per million fresh input tokens, $0.18 per million cached input tokens and $9.00 per million output tokens.
| Browse line | Tokens | Cost |
|---|---|---|
| Fresh input | 108,130 | $0.1946 |
| Cached input | 1,037,261 | $0.1867 |
| Output | 5,109 | $0.0460 |
| Total | $0.4273 |
The statement for the same window is $0.4273. The arithmetic and the invoice agree to the cent. This is the same reconciliation we ran against OpenCode's session cost panel in October: OpenCode now shows what every session costs.
For webfetch, the statement's $0.4684 decomposes as $0.3980 of fresh input, $0.0526 of cached input and $0.0178 of output. Both totals come from the same key and the same rate card.
The webfetch fresh-input count is derived from total prompt tokens minus client-reported cached input. One request had no step event, accounting for the 791-token difference from the client total. The gateway statement remains the billing source.
Why the browser was cheaper
The obvious guess is that a browser is heavier than an HTTP fetch. For this task, the opposite was true, and the reason is where new tokens enter the context.
Webfetch returns the page as markdown. Ten pages of pricing copy landed in the conversation as new input, about 22,000 fresh tokens for each page attempted. Browse's agent quickly switched from full snapshots to 18 targeted JavaScript evaluations. Those returned the price rows, not the whole page. The agent still sent its growing context on every request, but 91% of those prompt tokens were cache reads at one tenth the price; the mechanics are in our K3.1 Pro cache pricing note.
The same arithmetic explains the webfetch bill: only 57% of its prompt tokens were cached, because each fetched page was a large new block. The tool that fetched less got billed more.
What the screenshots did
We asked for screenshots of the first and last page. The model in this setup reported that it could not read images, so they added no usable information. Their token cost was not distinguishable from normal context growth, roughly 250 tokens across a step. If your model accepts images, check how image input is priced before budgeting a screenshot-heavy task.
Setup and boundaries
Install the extension from the Chrome Web Store, then run npx @opencode/browse install. The installer adds the MCP entry to your agent and pairs the browser through a local service on port 19988. browse status shows whether the local service and extension are connected. Pairing uses a one-time code that expires after ten minutes.
Three boundaries matter more than the setup:
- Allowed sites. Keep the agent on the sites you name. The extension can act on sites available to that browser profile, including logged-in sessions.
- A separate profile. For public pages, a dedicated Chrome profile with no logins keeps logged-in accounts out of the test. This run used one.
- Handoffs. Login, 2FA and payment steps are handed back to the human by design. That was not exercised here; the pages were public.
Troubleshooting
If browse status says the extension is not connected, start with the local service: the extension connects to 127.0.0.1:19988 by default, and the pairing code is valid for ten minutes. Re-pair rather than restarting the browser.
If a page returns no content, check whether it is JavaScript-rendered. Webfetch saw empty tables on Moonshot; the browser's DOM evaluation saw the prices. The reverse also happens: a page can be so large that a snapshot wastes context, which is why the agent moved to targeted evaluations.
Tabs pile up on long tasks. Close them when the task ends, or let the idle cleanup do it; the default idle close is 10 minutes.
When to use which
Webfetch is faster: 2 min 23 s against 8 min 44 s. For static documentation with clean HTML, that speed is the right trade.
Browse is for pages that need JavaScript, a click, or a login. In this run it cost 9% less than webfetch and read two more pages, because targeted DOM reads added less fresh input than full-page markdown. That result is one task on one day, not a ranking. The mechanism is what transfers: count fresh input, not page views, and check the cache line before you blame the browser.
A read-heavy ten-page task on Kimi K3.1 Pro landed at 4.3 cents a page. For the same-model tool comparison on a single bug fix, see Codex vs OpenCode vs Crush. Budget for the cold start, then watch the fresh-input line.
If you want to run the same test, Wallaby's Kimi K3.1 Pro endpoint is $1.80 per million fresh input tokens, $0.18 cached and $9.00 output, with an itemized statement for every key. New accounts get $0.50 in credit, no card required: create a key.