Go SDK Reference

match must be a CSS or JS Locator — Node and At are rejected. Use Locator.InAllFrames to watch every frame and Locator.Visible(false) to opt out of the default visibility gate.

match must be a CSS or JS Locator — Node and At are rejected. Use Locator.InAllFrames to watch every frame and Locator.Visible(false) to opt out of the default visibility gate.

Every request matching opts.Patterns is reported once it completes, and "every request" is literal: capture sits in the browser process rather than in a page, so cross-process iframes, workers and service workers are included, the headers are the ones actually put on the wire (Cookie and Sec-* included), and each hop of a redirect chain arrives as its own exchange. Requests are never paused, so the page loads at full speed.

This call returns as soon as the capture is running; onExchange then fires in the background while you drive the browser. The capture is armed only after the subscription exists, so nothing that happens after this call returns is missed. Call NetworkCapture.Stop when done — it disarms the capture server-side, which a cancelled context alone does not.

Reports only transport failures - a dead session, a page that is gone, a broken connection. This call has no semantic failure of its own, so there are no error codes to branch on.

The element does not have to be ready when you call this. For up to 5s the browser keeps re-locating it, scrolls it into view, waits for its bounds to hold still for 750ms, and hit-tests the exact point it is about to press — so a plain Click also does the work of a preceding CloudBrowser.Wait, and needs no retry loop of your own. If the element never settles within that budget the click is attempted at the deadline rather than abandoned.

If something covers the target, the pointer is repositioned once to an exposed part of it, which also gives hover-triggered overlays a chance to collapse. Only if the target is still covered afterwards does the click refuse — it never presses whatever happens to lie on top.

The cursor then moves along a human-like path rather than jumping, and a full mouseDown+mouseUp is dispatched at a randomized point inside the element's bounding rect.

The element does not have to be ready when you call this. For up to 5s the browser keeps re-locating it, scrolls it into view, waits for its bounds to hold still for 750ms, and hit-tests the exact point it is about to press — so a plain Click also does the work of a preceding CloudBrowser.Wait, and needs no retry loop of your own. If the element never settles within that budget the click is attempted at the deadline rather than abandoned.

If something covers the target, the pointer is repositioned once to an exposed part of it, which also gives hover-triggered overlays a chance to collapse. Only if the target is still covered afterwards does the click refuse — it never presses whatever happens to lie on top.

The cursor then moves along a human-like path rather than jumping, and a full mouseDown+mouseUp is dispatched at a randomized point inside the element's bounding rect.

Reports a plain error when the stop API or the connection close fails. The session is released either way; retrying a stop is safe.

Use this to detach without releasing the rental — the common case when you attached with ConnectSession to act on a session owned elsewhere, or when a short-lived handle should not outlive its work but the session must. Contrast with CloudBrowser.Close / CloudBrowser.StopBrowser, which also release the rental via the stop endpoint.

Reports a plain error when the connection cannot be closed cleanly. The local handle is unusable afterwards regardless.

The source is acquired with the same smart click as CloudBrowser.Click — re-located, scrolled into view, settled and hit-tested — so the handle does not have to be ready when you call this. The browser then presses the left mouse button at a point inside the element, drags along a human-like path to (pickupX+offsetX, pickupY+offsetY), and releases. At is not a valid target — drag needs a real element.

Same gesture and same source acquisition as CloudBrowser.DragBy, but the drop destination is in page coordinates rather than relative to the pickup point.

The expression's return value is JSON-serialized server-side and parsed eagerly into EvaluateResult.Value. When the expression returns a DOM element the EvaluateResult.Value is left empty and the element metadata (BackendNodeId, IsVisible, Bounds) is populated instead — use Node(id) in subsequent calls to act on it.

A falsy answer and a broken expression are different outcomes. Returning null, false or undefined is a successful evaluation and comes back as a result; an expression that throws or will not compile comes back as a *CommandError, so a typo can never read as "the page says null".

Same semantics as CloudBrowser.Evaluate but targets a specific frame instead of the main frame. Useful for evaluating inside OOPIFs (out-of- process iframes) found via CloudBrowser.GetPages.

The field is acquired with the same smart click as CloudBrowser.Click: re-located, scrolled into view, settled and hit-tested within the timeout budget, so it does not have to be present or ready yet. The cursor then moves along a human-like path and clicks to focus.

Typing is per-key rather than a value assignment: keyDown, char and keyUp for every character, with the keycodes of the layout that matches the session's region and human cadence between them. If the field already holds text the caret is moved to the end first, so appended input lands after the existing content instead of wherever the caret happened to sit.

Fill is strictly target-bound. If something else takes focus mid-typing, the remaining characters are never typed into the thief — the browser tries to re-focus the target and otherwise fails with "focus_stolen", naming the element that holds focus instead so you can deal with it (a consent button, a different field). For stream-style typing that is *supposed* to move between fields, such as an OTP input that auto-advances, use CloudBrowser.Type instead.

To overwrite the field instead of appending, use CloudBrowser.FillWith with ClearFirst: true.

At is not a valid target — Fill requires an actual element.

The field is acquired with the same smart click as CloudBrowser.Click: re-located, scrolled into view, settled and hit-tested within the timeout budget, so it does not have to be present or ready yet. The cursor then moves along a human-like path and clicks to focus.

Typing is per-key rather than a value assignment: keyDown, char and keyUp for every character, with the keycodes of the layout that matches the session's region and human cadence between them. If the field already holds text the caret is moved to the end first, so appended input lands after the existing content instead of wherever the caret happened to sit.

Fill is strictly target-bound. If something else takes focus mid-typing, the remaining characters are never typed into the thief — the browser tries to re-focus the target and otherwise fails with "focus_stolen", naming the element that holds focus instead so you can deal with it (a consent button, a different field). For stream-style typing that is *supposed* to move between fields, such as an OTP input that auto-advances, use CloudBrowser.Type instead.

To overwrite the field instead of appending, use CloudBrowser.FillWith with ClearFirst: true.

At is not a valid target — Fill requires an actual element.

For the case CloudBrowser.StartScript cannot cover: a run somebody else launched, or one this process started before it restarted. Several readers can watch the same session, each with its own buffer.

Only output produced from now on arrives — lines printed before the subscription existed are not kept. A run that has already finished is therefore invisible here; CloudBrowser.ListScriptRuns is how you tell that apart from a run that is merely quiet.

Returns nil, nil when the context has neither a signed-in account nor DBSC sessions.

The shape matches Chrome DevTools' Protocol DOM.Node — useful for piping into agent loops or visualizers that already speak CDP. For a much smaller agent-oriented payload, prefer CloudBrowser.GetObservation instead.

On an <iframe>/<frame>/<object> the one child is the document it hosts, and this call is what starts mirroring that frame.

Computing a hash is much cheaper than transferring the full tree — pair this with CloudBrowser.GetDOM only when the hash differs from your last snapshot.

Prefer it over CloudBrowser.GetDOMHash, which serializes the whole tree just to hash it. The two answer different questions: a hash compares content, a revision only says whether this document moved since you last asked. The counter is meaningful only within the current document.

Each frame opens with header lines carrying the URL, the title and the scroll position, then one line per visible element:

input#email47 type="email" name="loginId" value="a@b.com" required click "E-Mail"

It spans every frame, pierces open and closed shadow roots, enumerates <select> options, and reports live form state: value= is what is typed in right now (passwords as a length), checked= for boxes. The trailing quoted string is always the label or text, never the value, so an empty and a prefilled field stay distinguishable. Because the headers already carry URL, title and scroll offset, this replaces the usual handful of CloudBrowser.Evaluate probes after each step.

On what to do with the result: backendNodeId (the 47 above) is a handle for this session and can be passed straight to click/fill via Node. It does not survive a new document, so for anything you write into a script, target with CSS or JS instead — those calls return the backendNodeId they resolved to, which lets you confirm the durable anchor hits the element you saw.

Each frame opens with header lines carrying the URL, the title and the scroll position, then one line per visible element:

input#email47 type="email" name="loginId" value="a@b.com" required click "E-Mail"

It spans every frame, pierces open and closed shadow roots, enumerates <select> options, and reports live form state: value= is what is typed in right now (passwords as a length), checked= for boxes. The trailing quoted string is always the label or text, never the value, so an empty and a prefilled field stay distinguishable. Because the headers already carry URL, title and scroll offset, this replaces the usual handful of CloudBrowser.Evaluate probes after each step.

On what to do with the result: backendNodeId (the 47 above) is a handle for this session and can be passed straight to click/fill via Node. It does not survive a new document, so for anything you write into a script, target with CSS or JS instead — those calls return the backendNodeId they resolved to, which lets you confirm the durable anchor hits the element you saw.

Each PageInfo carries the page's URL, title, viewport and a full nested frame tree (out-of-process iframes are children of the page's main frame).

Walks every frame and returns the first non-empty selection found — useful for "copy what the user highlighted" flows. Returns an empty string when nothing is selected anywhere.

The storage database is read directly in the browser process, so no page needs to be open. Only first-party localStorage is included — sessionStorage is per-tab and not covered.

Live streaming is a two-step, client-offerer handshake: call GetStreamConfig, build your peer with the returned servers, create an offer, then pass its SDP to CloudBrowser.StartStream and apply the returned answer.

Everything but MinMemory and AverageMemory only ever grows, so polling and diffing two readings gives the cost of what ran in between. The final figures need no call of their own: CloudBrowser.StopBrowser returns them.

Useful for visual debugging of agent flows — the overlay stays until the next call. Pass backendNodeId <= 0 to clear any current highlights.

No individual key events are dispatched; the entire string is committed at once via Input.insertText. Whatever element currently has focus receives the text. Use CloudBrowser.Click or CloudBrowser.Fill first if you need a specific element to be focused.

Mirrors what the live-UI overlay does on hover. Elements with pointer-events:none are skipped — the result is the actual click target, not the visually-topmost node.

Only runs in flight — a finished run is reported once on the event stream and then forgotten, so this is not a history. Its use is finding work this caller did not start: a script a previous process left behind, which CloudBrowser.StopScripts needs an id to name.

Registers a one-shot interceptor that intercepts the next request to url and replies with the supplied html and headers instead of going to the network. Useful for snapshotted pages, test fixtures, and offline replays. Pair with CloudBrowser.Navigate to trigger the load.

One mirror covers the whole page as ONE tree. An <iframe> is an ordinary element whose single child is the document it hosts; expanding it fetches that document and starts mirroring the frame, however deeply nested and whether or not it is cross-origin. Unlike the inlining CloudBrowser.GetDOM does, these regions stay live — and frames nobody opened cost nothing.

This replaces polling CloudBrowser.GetDOMHash and re-fetching GetDOM: the browser reports changes to the part you actually expanded instead of re-serializing the document so you can hash it.

The subscription is established before the snapshot is taken, so no change between the two is lost. Call DomMirror.Stop when done — it stops the mirror server-side, which a cancelled context alone does not.

One-shot: consumes the first matching request. Pass nil/empty mods to leave headers untouched and only override the body.

The browser scrolls the target into view first if necessary, then animates the cursor along a human-like path to the element's random center area (or to the viewport coordinate when target is At).

Returns once the primary main-frame navigation commits (the response is received and a new document is selected), before DOMContentLoaded or load fire. Cross-origin redirects are followed.

Only the keydown half is dispatched — pair with CloudBrowser.ReleaseKey for a full press cycle. The event targets whichever element currently has focus.

Bodies are stored by the browser, not sent with the exchange, so reading one is a separate call. They stay readable after the capture stops, until the session ends.

The body is fetched in ranges and assembled in memory. For very large bodies, use CloudBrowser.ReadNetworkBodyRange to process them piece by piece.

A single call returns at most 2 MiB; length 0 reads that much. Loop on offset + len(Data) until it reaches TotalSize to stream a large body.

Skipping it is not an error, it is a slow leak: the browser's revealed set only grows, and eventually it is no longer filtering anything.

Mirror of CloudBrowser.PressKey. Same parameter semantics; use this to close a press cycle that was started with PressKey.

The script runs beside the browser, in a V8 isolate of its own rather than in the page, and reaches the document through the engine: a cross-origin iframe is read as plain contentDocument with no frame ids anywhere, values come back as live objects it can assign to rather than snapshots, an element can be handed straight to browser.click, and the page sees nothing injected. Steps cost microseconds rather than network round trips, so work that is chatty by nature — polling for a selector, walking a list, following pagination — is affordable there. A guide for it is still to come.

This blocks for as long as the script runs, and cannot be bounded: the run id needed to cancel only arrives with the reply. Cancelling ctx abandons the wait but not the run. Use CloudBrowser.StartScript when the script may outlive the caller's patience, or CloudBrowser.StopScripts to abandon what this session is running.

The capture uses a one-shot surface copy (the same mechanism as CDP Page.captureScreenshot), so it is independent of any active live stream and works with both GPU (hardware) and software compositing.

Whatever scroll container is closest to the element does the scrolling — nested scroll containers and out-of-process iframe chains are walked automatically. At is not a valid target here; scrolling needs a real element.

Sets the option as selected on the targeted <select>, then fires the standard input + change events (unless suppressed via CloudBrowser.SelectByIndexWith with SelectOpts.NoEvents).

At is not a valid target — Select requires an actual <select> element.

Sets the option as selected on the targeted <select>, then fires the standard input + change events (unless suppressed via CloudBrowser.SelectByIndexWith with SelectOpts.NoEvents).

At is not a valid target — Select requires an actual <select> element.

Sets the option as selected on the targeted <select>, then fires the standard input + change events (unless suppressed via CloudBrowser.SelectByIndexWith with SelectOpts.NoEvents).

At is not a valid target — Select requires an actual <select> element.

Sets the option as selected on the targeted <select>, then fires the standard input + change events (unless suppressed via CloudBrowser.SelectByIndexWith with SelectOpts.NoEvents).

At is not a valid target — Select requires an actual <select> element.

Sets the option as selected on the targeted <select>, then fires the standard input + change events (unless suppressed via CloudBrowser.SelectByIndexWith with SelectOpts.NoEvents).

At is not a valid target — Select requires an actual <select> element.

Sets the option as selected on the targeted <select>, then fires the standard input + change events (unless suppressed via CloudBrowser.SelectByIndexWith with SelectOpts.NoEvents).

At is not a valid target — Select requires an actual <select> element.

Call before navigating. Pair with SetCookies / SetStorage to fully restore a persona.

Any request whose URL matches one of the supplied patterns is blocked before it leaves the browser. Patterns are simple URL wildcards (* matches any character span). Pass a nil/empty slice to clear the blocklist and let everything through.

Existing cookies with the same (name, domain, path) tuple are overwritten. Pass an empty slice for a no-op.

Takes effect for new requests immediately; in-flight requests keep their original routing. Pass an empty proxyHost to clear the proxy and route directly.

Useful for replaying frozen page assets (HTML/JS/CSS/images) without hitting the origin every time. The cache backend itself (blob storage, CDN, …) is configured server-side. Pass an empty patterns slice to disable caching for this session.

Accepts the same structure GetStorage returns, so a dump can be fed back verbatim. Existing keys are overwritten. Works without any open page; pages that are already open will not observe the writes until they reload.

Detection covers the common challenge types you run into in the wild. The challenge is completed in-page server-side (the resulting token / bypass cookies are wired into the page automatically), so callers can ignore the returned string.

Calling it again restarts the mirror, which is also the recovery path after a resync. Subscribe before calling it: changes between the snapshot and the subscription are not replayed.

Use it when the reader lives somewhere else — another process, or a later ConnectSession against the same session. Most callers want CloudBrowser.CaptureNetwork instead, which arms and subscribes together. Calling this again replaces the running capture.

The counterpart to CloudBrowser.RunScript, for scripts that are not worth waiting on: a watcher that runs for the life of the session, work that should survive this process. Output arrives at onEvent while the caller gets on with something else, and ScriptRun.Wait collects the outcome if it is wanted.

Subscribing has to happen before the launch, because a detached run's output is not kept anywhere — the browser rejects a start with nobody listening rather than discard the script's log and result. This call does both in that order, so nothing the script prints is missed.

Reports only transport failures - a dead session, a page that is gone, a broken connection. Stopping a mirror that is not running is a no-op rather than a failure, so there are no error codes to branch on.

An empty runId cancels every run in the session, which is the only form available to a caller that never learned an id — notably one abandoning a blocking CloudBrowser.RunScript.

Reports only transport failures - a dead session, a page that is gone, a broken connection. Stopping a stream that is not running is a no-op rather than a failure, so there are no error codes to branch on.

Stopping the returned view detaches this reader and leaves the capture running, since other readers may still be attached.

Type is intentionally UNtargeted and loose: it does not locate or focus any element and does NOT pin focus, so the page is free to route keys and move focus between fields mid-stream — ideal for one-time-code / OTP inputs that auto-advance to the next box on each digit. To type one specific field that must stay focused for the whole value, use CloudBrowser.Fill instead (strict, target-bound, per-key focus-verified).

Nothing is focused for you: CloudBrowser.Click (or Fill) the field first, or otherwise ensure focus, before calling Type.

Pass one or more Locators (built with CSS, JS, …) plus optional wait-level arguments such as Timeout. When several locators are supplied, the first one to match wins; the others are abandoned.

Anything left unset is defaulted by the API, not by this SDK: - timeout: 30s — override with Timeout - per-locator visible and steady: visibility required, 500ms of settling. For JS expressions returning a non-Element value (bool/string/number/ object) both are no-ops. Override with Locator.Visible / Locator.Steady on individual locators.

Node and At are not valid wait conditions — they only make sense as action targets — and produce an error at send time.

Returns the matched pattern's index and the captured request. When patternsi.Abort is true the request is dropped with an empty 200 response instead of being sent to the network.

Same shape as CloudBrowser.WaitForAnyRequest but on the response phase. When patternsi.Abort is true the page receives an empty 200 instead of the real response.

Equivalent to .InFrame(AllFrames). Use this when an element might appear inside any of several frames and you do not want to enumerate them.