Anchor Browser

Anchor Browser gives AI agents a cloud browser with sessions, profiles, and identities. Agents open sessions, navigate and click, run plain-language web tasks, capture screenshots and PDFs, and react when a task completes or a human intervention is requested.

Verified 7 triggers 94 actions API key available

Anchor Browser website Platform Documentation Capability data verified 2026-08-25

On Intervention Requested fires because an agent driving a supplier portal reached a question it will not answer for itself

Get Requested Human Interventions reads the waiting request, its type, and the fields it is asking about

Save Session Screenshot To FlowRunner File captures what that browser is showing at this moment

Get Billing Info reports the project's remaining credit, because the blocked session keeps billing by the minute while it waits

The question, the screenshot, and the session's live view URL post to the operations channel with the deadline attached

The operator answers, and Respond To Human Intervention unblocks the agent with a reply shaped to the request type

What This Integration Enables

Anchor Browser gives an agent a real browser in the cloud: a session it can navigate, click, type into, screenshot, print to PDF, and sign in to, plus a set of tools that take a URL and do one thing with no session to manage at all. Fetch Webpage returns a rendered page past bot protection. Perform Web Task hands an agent a URL and an instruction in plain language. Generate Task turns a proven instruction into something deterministic that later runs the same way every time. Underneath, Create Profile and Create Identity solve the part that usually breaks first, which is staying signed in.

What makes this connector unusual is not any of that. It is that Anchor shipped a digital andon cord into its own agent runtime. An agent can stop mid task and ask a person a question, and the session waits. That is the same commitment FlowRunner is built around, which makes the two fit together without argument. It also exposes the gap Anchor deliberately left open: the vendor built the pause, not the supervisor. A question nobody answers is not a safe default, because the session is billing by the minute while it waits and its idle timeout is still running. FlowRunner is the part that routes the question to a named person on a channel they already watch, keeps the context attached, and resumes the run the moment the answer comes back. That is human-in-the-loop as orchestration rather than as a dashboard somebody is supposed to check.

Without FlowRunner

Agents that guess An automation that meets an unexpected question either picks an answer or fails, and neither outcome tells anyone what happened

Nobody owns the queue An agent stops to ask something and the question sits in a vendor console that no person has open

Sessions that outlive their work A cloud browser left running keeps billing until its own timeout, and nothing reconciles what was started against what stopped

With FlowRunner

Questions become work items An intervention request arrives on the channel a named person already watches, carrying the screenshot and the live view

A supervised queue One poll finds every blocked agent across the team, each with its session and its tags, so nothing waits unnoticed

Sessions accounted for Flows tag their own sessions, find them again, and end them, and the ones nobody can account for are surfaced rather than swept away

Use Case Scenarios

A signed in portal that has no API

A logistics team needs carrier rate confirmations that exist only inside a portal. Once, a person logs in inside a session and the agent calls Create Profile to capture the cookies and local storage. Every later run names that profile, so the browser starts already signed in. When the portal rotates credentials, On Identity Authentication Failed fires, the agent calls Update Identity with the new password and then Reauthenticate Identity, and the schedule carries on. The extracted confirmations land in Google Sheets and a summary posts to Slack. Nothing about this workflow required the portal to publish an API.
Scaling a proven task, with the spending in view

An analyst has one instruction that works. Generate Task turns it into a reusable task with input parameters, and Run Task executes it deterministically for a single input while the analyst watches. To run it across a list, Create Session Batch starts many identically configured sessions at once. Every session in that batch bills independently and Count goes into the thousands, so the flow reads Get Billing Info first and posts the number and the balance before it starts. Get Session Batch is then read for its per session errors rather than its status, because a batch can report completed having failed to start a large share of its sessions. If the configuration turns out wrong, Cancel Session Batch stops the spending and keeps the recordings; Delete Session Batch takes those recordings with it, which is why cleanup and cancellation are different decisions.
One queue for every agent that stopped to ask

A supervisor flow runs on a schedule and calls List Pending Human Interventions, which returns every agent waiting on a person across the team's active sessions, each with its session id and tags. Requests are routed by tag: billing questions to finance, portal questions to the operations channel, ambiguous data to the analyst who owns the source. Each message carries the live view URL so the reviewer can watch the actual browser, and a screenshot for the ones who will not open a link. Answers come back through Respond To Human Intervention. The same flow calls List Browser Sessions filtered on its own tags to reconcile what it started against what is still running, and ends its own strays with End Browser Session rather than reaching for End All Browser Sessions, which is scoped to the API key and would stop work other people started. Tickets that need a person rather than an answer open in Zendesk.

Human-in-Loop Highlight

An Anchor agent that stops to ask a question is not idle. The session it is holding bills by the minute and its idle timeout is still counting, so an unanswered question can end with the session dying and the work being lost, which is the expensive version of asking for help. On Intervention Requested is therefore treated as an operational event with a clock on it, not a notification. The agent's question arrives on the operations channel with the live view URL, a fresh screenshot from Save Session Screenshot To FlowRunner File, and the remaining credit from Get Billing Info, and it reads something like: "The purchase order total on this portal page is 4,180 dollars against a confirmation of 4,015 dollars. Submit as shown, correct the total, or abandon this run?" The operator picks one. Respond To Human Intervention sends an answer shaped to the request type, a string for a text request, a boolean for a confirmation, an object of field values for a field request, and the agent carries on inside a live signed in browser. The answer is the action here. That is exactly why it belongs to a person.

Agent processes routinely

Detects exception requiring judgment

Clear match Continues automatically

Ambiguous Routes to human via preferred channel

Human decides

Agent resumes with decision

Agent Capabilities

94 actions

Sessions

Start Browser Session Allocates a cloud browser and returns its id, its CDP URL, and its live view URL. It blocks while the pod provisions, and the session starts billing by the minute from that moment.
Start Browser Session Async Returns a request id immediately and provisions the browser in the background, so a flow can do other work while the pod starts.
Get Async Session Status Reports whether a background session request has finished provisioning and returns its ids and URLs once it has.
Get Browser Session Returns a session's status, configuration, and URLs. A not found response here usually means the session ended on its own through Max Duration or Idle Timeout.
End Browser Session Terminates a running browser and stops it billing. The operation a flow must not forget, because a session left alone bills until its own timeout elapses.
End All Browser Sessions Terminates every session this API key has running. It is not scoped to one flow, so it stops work other flows and other people started with the same key.
List Browser Sessions Returns every session on the key with filters for tags, domains, creation time, batch, proxy, and profile. This is how a flow finds sessions it forgot.
Get Sessions History Returns session usage analytics for the team, aggregated by hour, day, week, or month. The reporting view rather than the live one.
List Session Pages Returns the tabs open in a session with their URLs and titles, which is how a flow learns where an agent actually ended up.
Get Session Tags Returns the labels on a session.
Set Session Tags Sets the labels on a session. It replaces the whole list rather than appending, so read the tags first if you mean to add one.
Clear Session Tags Removes every label from a session.
List Session Downloads Returns metadata for the files a session downloaded. A PDF only lands here when the session's PDF viewer is turned off.

Recordings

List Session Recordings Returns the session's video recordings and their URLs. Empty when recording was turned off for the session.
Save Session Recording To FlowRunner File Downloads a session's primary recording as MP4 into FlowRunner's own file storage, so the evidence outlives the session.
Pause Session Recording Stops recording without ending the session. The privacy control: pause before an agent types a password or a card number, resume after.
Resume Session Recording Starts recording again after a pause.
Delete Session Recording Removes a recording. The identifier primary refers to the session's main recording, which is what Anchor's own links point at.

Session control

Navigate To URL Points the session's browser at a URL.
Mouse Click Clicks at coordinates or on a CSS selector. A selector survives a viewport change; coordinates do not.
Mouse Double Click Double clicks at coordinates. Unlike a single click this one takes no selector.
Mouse Down Presses a mouse button at coordinates without releasing it, which is how a gesture too complex for Drag And Drop gets built.
Mouse Up Releases a mouse button at coordinates.
Mouse Move Moves the cursor without clicking. What triggers a hover menu, and what makes a drag look human.
Drag And Drop Drags from one coordinate pair to another. Some implementations need intermediate movement, in which case the manual sequence is the fallback.
Scroll Scrolls from a point by a delta. Breaking the scroll into steps is what makes an infinite scroll page actually load more.
Type Text Types into whatever currently has focus. It does not focus anything itself, so click the field first.
Keyboard Shortcut Presses several keys at once, which is how a page's own shortcuts are reached and how a prefilled field is selected before being typed over.
Get Clipboard Content Returns what is on the session's clipboard. The practical way to extract text a page will not let the DOM select.
Set Clipboard Content Puts text on the session's clipboard, which is how a long value reaches a field that ignores synthetic typing.
Copy Selected Text Copies the page's current selection to the clipboard.
Paste Text Pastes at the cursor. Like typing, it does not focus anything on its own.
Save Session Screenshot To FlowRunner File Captures what the session is showing and stores the image in FlowRunner's file storage. The fastest way to show a reviewer what the agent is actually looking at.
Upload File To Session Puts a file into the session's uploads directory so a web form's file input can use it. The flow still has to click the input.

Agent

Upload Agent Resource Puts a file where the session's AI agent can read it. A ZIP is extracted automatically, so a reference folder arrives in one call.
List Agent Resources Returns the files uploaded for the session's agent with their names, sizes, and types.
Pause Agent Stops the AI agent running in a session while leaving the browser open. How a flow takes the wheel back, or holds an agent while a person is asked something.
Resume Agent Lets a paused agent carry on. The session's idle timeout keeps running during a pause, so a long one can end the session underneath it.
Get Requested Human Interventions Returns the questions an agent in one session is waiting on. Populated only when the task was started with human intervention turned on.
List Pending Human Interventions Returns every waiting request across the team's active sessions with their session ids and tags. One poll finds every agent that stopped to ask.
Respond To Human Intervention Answers a waiting agent and unblocks it. The answer's shape follows the request's type: text, a confirmation, or an object of field values.

Tools

Perform Web Task Gives an agent a URL and a plain language instruction and lets it drive the browser. The operation to reach for before building a click by click sequence.
Get Web Task Status Reports whether an asynchronous web task has finished and returns its result.
Fetch Webpage Returns a fully rendered page from any URL, including bot protected ones, with no session to manage. The cheapest thing that works when a flow only needs content.
Save Webpage Screenshot To FlowRunner File Captures any URL as an image in FlowRunner's file storage, with full height and scroll options for a whole page.
Save Page PDF To FlowRunner File Prints a page to PDF into FlowRunner's file storage. Background printing is off by default, which is why a styled page can come out looking blank.
Execute Code Snippet Runs a TypeScript snippet in Anchor's sandbox against a live session, with the page, browser, context, and client injected. The escape hatch for anything the named operations do not cover.

Tasks

Generate Task Builds a reusable task from a natural language description, optionally using a finished session as a demonstration. A generated task runs deterministically rather than being reasoned out again.
Get Task Generation Status Reports whether a generated task is ready to run.
Run Task Executes a generated task with its input parameters. Asynchronous by default, returning a run id the flow follows.
Get Task Run Status Returns a run's status and, once finished, its output, artifacts, and recording link. Addressed by run id, because one task has many runs.

Batches

Create Session Batch Starts many identically configured browser sessions at once. Every session bills independently and the count goes into the thousands, which makes this the most expensive call in the connector.
List Session Batches Returns the team's batches with filters for status and creation time.
Get Session Batch Returns a batch's progress, its sessions, and its per session errors. Read the errors, because a batch reports completed having failed to start part of itself.
Cancel Session Batch Cancels a running or pending batch and terminates its sessions. The stop spending button, and it keeps the recordings.
Delete Session Batch Terminates every session in a batch and removes all of their data, recordings and downloads included. Cancel keeps the evidence; this does not.
Retry Session Batch Starts fresh sessions for the ones in a batch that failed. They are new sessions and bill as new sessions.

Profiles

Create Profile Captures a running session's cookies, local storage, and cache as a reusable profile. Sign in once, then name the profile on every later session.
List Profiles Returns every stored profile.
Get Profile Returns one profile, addressed by name rather than by an id.
Delete Profile Removes a stored profile. Sessions configured to use it start without it rather than failing, which is why a flow that quietly stops being signed in has usually lost its profile here.

Identities

Create Identity Registers a login Anchor performs and maintains for you from a source URL and credentials. The managed alternative to capturing a profile by hand.
Get Identity Returns one identity and its authentication state. Credentials are never returned.
Update Identity Changes an identity's name, metadata, or credentials. Where a rotated password goes, and what un breaks an identity whose logins started failing.
Delete Identity Removes an identity and its stored credentials.
Reauthenticate Identity Checks an identity's saved profile and signs in again if it is no longer valid, then stores the refreshed profile. The fix for sessions that quietly start logged out.

Applications

Create Application Registers a site whose logins Anchor manages, so identities can be grouped under it.
List Applications Returns the team's applications, optionally filtered by name.
Get Application Returns one application.
Delete Application Removes an application.
List Application Identities Returns the identities linked to an application, with a metadata filter that makes multi tenant lookups possible.
Create Identity Token Issues a token that starts an authentication flow so an end user can connect their own account. The operation that keeps a customer's password out of your flow entirely.
List Authentication Flows Returns the ways an application can be signed in to, such as password, single sign on, or a code.
Create Authentication Flow Defines how an application can be signed in to, including which flow a user is offered first.
Update Authentication Flow Changes an authentication flow. Only the fields sent are altered.
Delete Authentication Flow Removes an authentication flow from an application.

Extensions

Upload Extension Stores a browser extension so sessions can load it. It must be a ZIP of the unpacked extension, and Anchor validates it on upload.
List Extensions Returns the stored browser extensions and their ids.
Get Extension Returns one extension's details.
Delete Extension Removes a stored extension. Sessions configured to load it start without it rather than failing.

Integrations

Create Integration Connects a secrets manager so sessions can load credentials from it, which is the alternative to storing credentials on an identity.
List Integrations Returns the team's integrations and their ids. Stored credentials are never returned.
Delete Integration Removes an integration and its stored credentials.

Certificates

Upload Certificate Stores a CA certificate for sessions to trust, which is how an internal service behind a corporate authority is reached without turning off web security.
List Certificates Returns the team's stored CA certificates.
Delete Certificate Removes a stored CA certificate. Running sessions keep it; new ones no longer trust that authority.

Coordination

Signal Event Releases anything waiting on a named event and hands it data. Anchor's own rendezvous between a running session and the rest of a flow.
Wait For Event Blocks until a named event is signalled or the timeout passes. A wait for something that never arrives costs the whole timeout.

Account

Get Billing Info Returns the project's credit balance, current period usage, tier, and limits. The operation to put in front of a batch.

Webhooks

List Webhooks Returns the project's webhooks, including the ones this connector's triggers registered. Anchor allows a small fixed number per project, and every running trigger counts against it.
Get Webhook Returns one webhook's configuration. The signing secret is never returned.
List Webhook Deliveries Returns every delivery attempt, successful, failed, or dead lettered. Where a silent trigger explains itself.
Send Test Webhook Event Fires a synthetic event of a chosen type through the real signing and retry path, to prove an endpoint verifies signatures and is reachable.
Rotate Webhook Secret Mints a new signing secret and returns it once. The old secret stays valid for a day, which is the window to update verification without dropping deliveries.

Triggers

7 triggers

Event Triggers

On Task Completed Fires when a task run finishes successfully, carrying the run id, the structured output, the artifacts list, and a recording URL, so a flow gets the whole result without polling.
On Task Failed Fires when a task run fails, with an error type that separates an automation failure from invalid credentials, a timeout, an agent error, or a system error. Each one deserves a different branch.
On Session Completed Fires when a browser session ends, however it ended. The reliable place to collect a session's downloads and reconcile what a flow started against what stopped.
On Session Failed Fires when a session fails to start or dies, so a flow notices its session never existed rather than discovering it on the next control call.
On Session Recording Ready Fires when a recording has finished processing. A recording link on a completed task is not necessarily a file yet; this event is what says it is.
On Intervention Requested Fires when an agent stops and asks a person something. The agent is blocked and the session keeps billing until somebody answers, which is why this one is routed to a person rather than logged.
On Identity Authentication Failed Fires when Anchor could not sign an identity in. The early warning that a stored credential has gone stale, before it surfaces as a task failing for reasons that look unrelated.

Frequently Asked Questions

What can FlowRunner do with Anchor Browser?

FlowRunner agents can run Start Browser Session, Start Browser Session Async, and Get Async Session Status in Anchor Browser, plus 91 more actions.

Does connecting Anchor Browser to FlowRunner require OAuth?

No. Anchor Browser connects to FlowRunner with an API key, no OAuth flow required.

Can Anchor Browser trigger a FlowRunner workflow automatically?

Yes. Anchor Browser supports 7 triggers that can start a FlowRunner workflow automatically.

Start building with Anchor Browser

Free plan, no card required. Connect in minutes.

Start Building Free Talk to us