# AI Employee Browser Use vs Integrations: How to Decide

> By Kris Newlin · Published 2026-08-23 · Updated 2026-11-06
> Source: https://viktor.com/blog/when-should-your-ai-employee-use-a-browser

An AI employee should use an integration (an API connection) whenever one exists, and fall back to browser automation only for systems that will never offer one: broker and insurer portals, government filing sites, supplier back offices and legacy tools. Integrations are faster, return structured data and fail with a clear error. A browser session is slower and can fail quietly halfway through a form, so it earns its place on the read-only last mile of a workflow, with screenshots as evidence and approvals on anything that submits, pays or contacts someone outside the company.

## Key takeaways

- **Integrations first, browser second.** An API call is faster and fails loudly. A browser session fails quietly, mid-form, on a page that moved a button.
- **The browser earns its place on the last mile.** Old portals, insurer sites, government filings, county tax lookups and supplier back offices will never publish an API.
- **Browser agents got much better in 2026.** Anthropic made computer use generally available on August 20, 2026 and added a browser tool that reads page structure instead of guessing at pixels.
- **Screenshots are the audit trail.** If a browser run cannot show what it saw and what it clicked, you cannot approve it, and it should not run unattended.
- **Write the rule down once.** Which systems the browser may touch, which it may only read, and which actions always come back as a draft.

## Browser automation vs API integration: what is the difference?

An **integration** is a direct line into another system. Your [AI employee](https://viktor.com/ai-employee) authenticates once, then asks for exactly what he needs: this invoice, that contact record, last week’s ad spend. The system answers in structured data, and a bad request comes back as an error, not a guess.

A **browser session** is the other path. The AI employee gets a real browser, loads the page, reads it and acts the way a person would: click the field, type the value, press submit. Viktor drives that browser with screenshots plus the page’s structure, so he can work in tools that were never built for automation.

```json:object
{
  "_key": "k40",
  "_type": "table",
  "rows": [
    {
      "_key": "k33",
      "_type": "tableRow",
      "cells": [
        " ",
        "API integration",
        "Browser automation"
      ]
    },
    {
      "_key": "k34",
      "_type": "tableRow",
      "cells": [
        "Speed",
        "Milliseconds per call",
        "Seconds per page"
      ]
    },
    {
      "_key": "k35",
      "_type": "tableRow",
      "cells": [
        "Data returned",
        "Structured fields",
        "Whatever the page shows"
      ]
    },
    {
      "_key": "k36",
      "_type": "tableRow",
      "cells": [
        "Failure mode",
        "Clear error",
        "Partial run that can look finished"
      ]
    },
    {
      "_key": "k37",
      "_type": "tableRow",
      "cells": [
        "Breaks when",
        "The API version changes (rare, announced)",
        "The page layout changes (often, unannounced)"
      ]
    },
    {
      "_key": "k38",
      "_type": "tableRow",
      "cells": [
        "Best for",
        "Any system with a supported connection",
        "Portals and legacy tools with no API"
      ]
    },
    {
      "_key": "k39",
      "_type": "tableRow",
      "cells": [
        "Audit trail",
        "Logs in both systems",
        "Screenshots of every step"
      ]
    }
  ]
}
```

Here is how that plays out on real jobs:

```json:object
{
  "_key": "k50",
  "_type": "table",
  "rows": [
    {
      "_key": "k43",
      "_type": "tableRow",
      "cells": [
        "Job",
        "Integration path",
        "Browser path"
      ]
    },
    {
      "_key": "k44",
      "_type": "tableRow",
      "cells": [
        "Pull last week’s Stripe revenue",
        "Direct query, structured numbers back",
        "Slow, and the dashboard renders differently on every screen"
      ]
    },
    {
      "_key": "k45",
      "_type": "tableRow",
      "cells": [
        "Update a HubSpot deal stage",
        "One write, confirmed by the record",
        "Works, but you are trusting a click on a dropdown"
      ]
    },
    {
      "_key": "k46",
      "_type": "tableRow",
      "cells": [
        "Download a certificate of insurance from a broker portal",
        "No API exists",
        "The only way it happens without a person"
      ]
    },
    {
      "_key": "k47",
      "_type": "tableRow",
      "cells": [
        "File a form on a county tax site",
        "No API exists",
        "The only way it happens without a person"
      ]
    },
    {
      "_key": "k48",
      "_type": "tableRow",
      "cells": [
        "Adjust a Google Ads budget",
        "Direct write, logged in the account",
        "Fragile, and the interface changes monthly"
      ]
    },
    {
      "_key": "k49",
      "_type": "tableRow",
      "cells": [
        "Read a supplier’s order status page behind a login",
        "Rarely available",
        "Reliable enough to run daily"
      ]
    }
  ]
}
```

When a real connection exists, use it. The browser is for the systems that will never give you one.

## How to decide: the four-question rule

The whole decision takes about ten seconds:

1. **Is there a supported integration?** If yes, use it. Viktor connects to 9,800+ tools with read and write access, so the answer is usually yes.
2. **If not, is the job read-only?** Log in, read the page, bring back the numbers or the file. Low risk, easy to verify and a good candidate for a schedule.
3. **If it writes something, who owns the consequence?** Submitting a filing, changing a shipping address or cancelling an order should come back as a draft or a confirmation request first.
4. **Would you give this login to a new hire in week one?** If not, do not give it to a browser session either. That is a permissions decision, not a technology one.

A typical read-only browser job looks like this:

```
@Viktor log into the broker portal every Monday, pull the current certificates of insurance for all active vendors, save them to the Vendor COIs drive folder, and post a summary in #ops with anything expiring in 30 days.
```

It repeats, it only reads, and it produces evidence. That is the best use of a browser: the boring last mile of a workflow that is otherwise fully connected. One operations lead used to spend four hours every quarter doing exactly this by hand across twelve certificates.

## Why browser agents matter more in 2026

The capability is not new. What changed is that it became reliable enough for regulated buyers. On August 20, 2026 Anthropic moved computer use to general availability and shipped a browser use tool that acts on a named field or button instead of a coordinate on a screenshot, the difference between “click the third box” and “click the policy number field”. Computer use also became eligible for HIPAA-regulated workloads under Anthropic’s business associate agreement, which shows where the demand comes from: healthcare and insurance back offices full of systems with no API.

This is also where the old RPA debate comes back. A recorded script that clicks the same coordinates every time is RPA, and it breaks the moment the page moves. An AI employee reading the page decides what to click at runtime, which usually survives a redesign. That is a better failure mode, not a guarantee. For a wider comparison of tools in this space, see our guide to [AI browser automation tools](https://viktor.com/blog/ai-browser-automation-tools).

## Where browser work goes wrong

Three failures come up again and again, and all three are manageable if you name them up front.

- **Silent partial success.** The session logs in, fills six of eight fields, hits a validation error it cannot read and stops. An API call would have returned a clear error. Require every browser job to report what it saw, not just what it did.
- **Expired sessions and two-factor prompts.** Portals log you out, rotate passwords and ask for codes at the worst moment. Decide in advance whether a failed login pings a person or waits for the next run.
- **Doing something a person would have questioned.** A person filing a form notices when an amount is off by an order of magnitude. Anything that submits, pays, cancels or emails an outside party should come back as a draft.

These are the same three risks you would manage with a temporary worker who has portal access and a to-do list.

## How to set up browser access safely

A browser session with a saved login is, in practice, an account acting on your behalf. Treat it like one.

- **Give it its own credentials.** Not the CFO’s login, but a named account you can see in the portal’s user list and switch off in one click.
- **Scope what it can reach.** Use read-only roles where the portal offers them. Most do, and few teams use them.
- **Require evidence.** Screenshots of every page a value came from make the output checkable in ten seconds instead of ten minutes.
- **Keep the browser off connected tools.** If a tool has an integration and the browser is still being used, someone skipped a step.

When a portal changes, the instruction stays short:

```
@Viktor the carrier portal added a new coverage tab. Update the Monday COI run: pull the new tab too, flag any vendor whose limits dropped since last month, and show me before and after screenshots in the thread before you file anything.
```

Browser work will always be slower than an integration. That is fine for a Monday job that used to take a person four hours. It is not fine as the default path for a tool that already offers a clean connection, which is the most common mistake teams make when they first try computer use.

## A quick way to decide this week

Take your team’s five most annoying recurring tasks. For each, list the systems it touches and mark each one: connected, no connection, or connection available but not set up. The third group is usually the biggest, and it does not need a browser at all, only a few minutes on an authorisation screen.

What is left, the genuinely unconnectable portals, is your browser list. It is usually two or three systems, the ones your team complains about by name. Start there, run read-only for two weeks, and only then decide whether anything on the list should be allowed to submit. If you are new to the idea, start with [what an AI employee is](https://viktor.com/blog/what-is-an-ai-employee) and how he splits work between integrations and the browser.

## FAQ

### When should an AI employee use a browser instead of an integration?

Only when no supported connection exists for that system. Integrations are faster, return structured data and fail with a clear error. A browser session is the fallback for portals, legacy back offices and government or insurer sites that will never publish an API.

### Is browser automation reliable enough for daily work?

For read-only jobs, yes, especially now that tools act on page structure rather than screen coordinates. For jobs that submit or pay, keep a human approval step and plan for partial runs that look finished.

### Is browser automation the same as RPA?

1. RPA replays fixed steps and needs maintenance every time a page moves. An AI employee decides what to click based on what is on the screen at runtime, so small layout changes usually do not break the job.

### Does Viktor use a real browser?

Yes. When a tool has no connection, Viktor opens a real browser session, works the page and reports back in Slack or Microsoft Teams with what he saw. He connects to 9,800+ tools directly, so the browser is the exception, not his first route.

### How do I stop a browser session from doing something risky?

Give it its own scoped account, prefer read-only roles, and set a review boundary so anything that submits, pays, cancels or contacts an outside party comes back as a draft. Switching the account off in the portal is the kill switch.

### What happens if the portal changes its layout?

A recorded script breaks. An AI employee reading the page usually adapts, but not always, so a layout change should show up as a flagged run rather than a silent skip. Screenshots on every run let you see the change the week it happens.

## Put your portal work on autopilot

Pick the portal your team complains about most and hand the read-only job to Viktor. [Start free with up to $100 in credits](https://app.viktor.com/signup), no credit card required.