Documentation

Scout docs

Scout exposes capability-owned surfaces that agent clients can make available to the agent running inside them. Runtime surfaces like browser, canvas, extension, and payment live inside one browser runtime, while platform adapters pair through their own runtime.

Runtime surfaces & adaptersExtension-backed browser stateMCP auth or extension provider key
What it is

A browser automation environment for AI agents

Scout is a browser automation environment with capability-owned surfaces. Agent clients expose the selected surface's tools to the agent running inside the client.

Public runtime surfaces like browser, canvas, extension, and payment live inside one browser runtime, and platform adapters pair on their own boundary, so the agent only gets the capabilities the workflow actually needs.

The extension has its own app path and bundled tool surface; it is not configured as another public surface.

Each surface owns its capability boundary, endpoint, tool catalog, and runtime adapter.

The shared runtime handles auth, request identity, allowance resolution, and transport.

Setup paths

Agent clients or Chrome extension

Scout has two setup paths: agent clients connect to public surfaces for external workflows, and the extension app path for real-browser workflows.

IDE and CLI agents install or configure only the public surfaces their agent needs, then authenticate with OAuth or an access token.

The extension uses Scout's app flow and its own built-in tool surface for real-browser workflows.

Extension users provide an AI provider or gateway key in settings so Scout can route model requests.

How to start

Choose your path, then configure it

Start by choosing the path you are actually using. Agent clients need surface configuration and auth; the Chrome extension needs the app install and a provider key.

For Claude Code, IDE agents, or CLI harnesses, configure the browser runtime for browser, canvas, extension, or payment workflows, and add the Figma adapter only when design-file work is in scope.

For agent clients, use OAuth by default and create access tokens only for CI, scheduled jobs, and non-interactive clients.

For the Chrome extension, add the AI provider key from the model provider you want to use; do not copy runtime configs into the extension.

Verify agent connections with tool discovery before attempting longer automations.

Choose your browser path

Pick the browser context your workflow actually needs before you wire an MCP client.

Hosted browser connector

The default browser-automation path. Configure the browser MCP server in your client, authenticate, and let Scout run browser automation through that connector.

Browser state

Clean connector-managed browser sessions. No extension. No existing cookies or tabs unless the workflow attaches to a chosen browser target.

Best for

IDE agents that need a standard MCP server

CI, scheduled jobs, scraping, and isolated runs

Automation that should not inherit your personal browser state

Requirements

An MCP-compatible client

The public browser connector endpoint at https://mcp.scout.i.ng/browser

OAuth for normal use, or a Scout MCP token only when browser-based auth is impossible

Chrome extension app

The app path. The extension uses Scout's built-in runtime to operate your real browser with the AI provider key you supply.

Browser state

Your real Chrome session via the Scout extension and Scout's app-side runtime.

Best for

Workflows that require your real logged-in browser

Using existing tabs, sessions, cookies, and extension state

Operator-style tasks where the browser should remain visible and persistent

Requirements

The Scout Chrome extension

A connection to Scout's app runtime

An AI provider or gateway API key in extension settings

A workflow that explicitly benefits from existing authenticated browser state

Connector server setup

Configure the hosted browser connector, authenticate, then verify the tool catalog with a small real call.

Client

Connect Cursor to Scout's hosted browser connector, complete browser-based OAuth, and verify the tool catalog before you start using Scout in chat.

Setup

Add the Scout browser connector entry to .cursor/mcp.json.

Save the file and let Cursor reload the MCP configuration.

Choose the Scout server when Cursor prompts to connect.

SnippetJSON
// Add to Cursor settings: .cursor/mcp.json
{
  "mcpServers": {
    "scout": {
      "type": "http",
      "url": "https://mcp.scout.i.ng/browser"
    }
  }
}
Authentication

Cursor should open the browser sign-in flow automatically on first connect. Complete the OAuth prompt, then return to Cursor and confirm the Scout server appears under MCP tools.

Verify

Open Cursor Settings > Tools & MCP and confirm the Scout server is connected.

Ask Cursor: "List the Scout MCP tools available in this workspace."

Run a low-risk verification task such as: "Use Scout MCP tools to open example.com and snapshot main."

Access tokens

Use Scout MCP tokens only for clients and jobs that cannot complete browser-based OAuth.

When to use MCP tokens

Use browser-based OAuth for normal interactive setup. Switch to access-token authentication only when your client cannot complete the sign-in flow or when you need non-interactive automation.

Steps

Prefer OAuth discovery for local development and everyday IDE use.

Use a Scout MCP token only for CI, scheduled jobs, or MCP clients without browser-based OAuth.

Keep the token scoped to the narrowest environment you can tolerate, ideally development or staging.

Revoke the token when the integration or job no longer needs it.

CI and headless automation

For CI or headless automation, attach a Scout MCP token as the Authorization header. This keeps the transport the same while bypassing browser-based login.

Steps

Generate a Scout MCP token from the Scout account UI or token management flow.

Store it in your CI secret store instead of committing it to the repo.

Inject it into the MCP client config as a Bearer header at runtime.

Rotate or revoke it after the automation job, especially for temporary workflows.

Programmatic MCP clients

Programmatic MCP callers can also use a Scout MCP token when they cannot complete OAuth. The auth shape is the same once the request reaches Scout: a userId plus derived workerId, with tokenId included for token-based access.

Steps

Use OAuth-derived MCP tokens when you can.

Fall back to a Scout MCP token only when browser sign-in is impossible.

Keep the token in environment variables or your secret manager.

Verify the connection with listTools() before starting a long-running job.

Environment variables

Optional configuration knobs for MCP clients, BYOK provider keys, and wallet-backed payments.

MCP Token

Optional

Fallback credential for CI or non-OAuth clients. Supply it as a Bearer header when your MCP client cannot complete the browser sign-in flow.

SnippetTEXT
smt_xxxxx.yyyyy

AI Provider Key (BYOK)

Optional

Your personal AI provider or gateway key for BYOK mode. Configure it in the extension settings so model usage is billed directly by the provider you choose.

SnippetTEXT
sk-...

Wallet Private Key

Optional

Supply it as the X-Wallet-Private-Key request header on the browser MCP server. Only the payment tools (balance, pay, transfer) read it for the current request; Scout never stores it. Chrome extension users set it in extension settings instead.

Wallet Network

Optional

Supply it as the X-Wallet-Network request header on the browser MCP server. Defaults to Base Sepolia (testnet). Set to base for mainnet wallet-backed assets.

Default: base-sepolia

Security recommendations

Keep capability, identity, and browser-state boundaries explicit.

Keep AI automation away from production by default

Do not default to production data when connecting an MCP client. Prefer development or staging environments, and keep real customer data away from exploratory AI workflows whenever possible.

Review tool calls, especially after reading untrusted content

Leave manual approval enabled in your MCP client and review tool calls before execution. Prompt injection remains a real risk whenever the model can read untrusted page content and then decide what to run next.

Use the right browser path for the risk level

Prefer hosted browser connector sessions for scraping, testing, and untrusted sites. Reserve the extension path for workflows where you explicitly want your real browser cookies, sessions, and authenticated state.

Treat MCP tokens like high-value secrets

Scout MCP tokens are powerful credentials. Store them in secret managers, scope them narrowly, rotate them when workflows change, and revoke them when an integration ends.

Constrain access rather than relying on the model to behave

Reduce the available action set when possible. Install or configure only the connector MCP servers needed for the workflow, and use the shortest-lived credential that still satisfies the automation.

Quickstart snippets

Small, copyable examples for the browser connector loop.

MCP token

SnippetJSON
{
  "mcpServers": {
    "scout": {
      "type": "http",
      "url": "https://mcp.scout.i.ng/browser",
      "headers": {
        "Authorization": "Bearer <mcp-token>"
      }
    }
  }
}

Programmatic client fallback

SnippetTYPESCRIPT
import { Client } from "@modelcontextprotocol/sdk/client";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(
  new URL("https://mcp.scout.i.ng/browser"),
  {
    requestInit: {
      headers: {
        Authorization: "Bearer " + process.env.SCOUT_MCP_TOKEN,
      },
    },
  },
);

const client = new Client({ name: "batch-runner", version: "1.0.0" });
await client.connect(transport);

const { tools } = await client.listTools();
console.log(tools.map((tool) => tool.name));

const result = await client.callTool({
  name: "browser-launch",
  arguments: { url: "https://example.com" },
});

console.log(result);

Snapshot filtering guide

Trim the accessibility tree before extraction to cut tokens and keep the model focused.

Exclude Decorative Elements

Strip decorative elements (icons, separators, generic containers) that add tokens without useful information.

Impact

Varies by page — contributes to up to 75% combined reduction with other filters

SnippetTYPESCRIPT
browser-snapshot({ excludeDecorative: true })

Role-Based Filtering

Filter the accessibility tree by ARIA roles. Remove roles that aren't relevant to your task — for example, exclude 'img' and 'separator' when extracting text content.

Impact

20–40% reduction depending on page structure

SnippetTYPESCRIPT
browser-snapshot({ excludeRoles: ["img", "separator", "presentation"] })

Depth Limiting

Limit how deep the accessibility tree is traversed. Shallow depths (2–4) capture top-level navigation and headings. Deeper depths (6–8) capture interactive elements inside nested components.

Impact

Configurable — deeper pages benefit most

SnippetTYPESCRIPT
browser-snapshot({ maxDepth: 4 })

Element Scoping

Scope the snapshot to a specific element using a CSS selector. Only the subtree rooted at the matched element is included. Ideal when you know the content region (e.g., 'main', '#content', 'article').

Impact

50–75% reduction when scoping to content region

SnippetTYPESCRIPT
browser-snapshot({ selector: "main" })

Stacked Filtering

Combine multiple filters for maximum reduction. The recommended starting point for most extraction tasks: scope to main content, remove decorative nodes, and limit depth.

Impact

Up to 75% combined reduction

SnippetTYPESCRIPT
browser-snapshot({ selector: "main", excludeDecorative: true, maxDepth: 6 })

Recipes

Small, copyable end-to-end recipes for common extraction and automation tasks.

Extract Structured Data

Navigate to a page and extract content using DOM property extraction.

Steps

Navigate to the target URL

Snapshot the main content area with decorative filtering

Use browser-extract with property: 'article' for clean content or 'text' for element text

SnippetTYPESCRIPT
// 1. Navigate to the target page
await callTool("browser-navigate", {
  action: "goto",
  url: "https://example.com/products",
});

// 2. Take a filtered snapshot (main content only)
const snapshot = await callTool("browser-snapshot", {
  selector: "main",
  excludeDecorative: true,
});

// 3. Extract article content (clean markdown via Defuddle)
const article = await callTool("browser-extract", {
  property: "article",
});

// 4. Or extract specific element text
const heading = await callTool("browser-extract", {
  property: "text",
  selector: "h1",
});

Fill and Submit Forms

Fill form fields and submit using element refs from the accessibility snapshot.

Steps

Snapshot the page to discover form field refs

Fill each field using browser-interact with action: fill

Click the submit button

Re-snapshot to verify the result

SnippetTYPESCRIPT
// 1. Snapshot to find the form
const snapshot = await callTool("browser-snapshot");

// 2. Fill in the form fields using @e refs from the snapshot
await callTool("browser-interact", {
  action: "fill",
  elementRef: "@e12",        // email input
  text: "user@example.com",
});
await callTool("browser-interact", {
  action: "fill",
  elementRef: "@e14",        // password input
  text: "secure-password",
});

// 3. Click the submit button
await callTool("browser-interact", {
  action: "click",
  elementRef: "@e18",        // submit button
});

// 4. Wait for navigation and verify
const result = await callTool("browser-snapshot");

Batch Operations Pipeline

Chain navigate → snapshot → extract in a single batch call to minimize round-trips.

Steps

Define all operations as an array of { tool, params } objects

Send them all at once with browser-batch (max 10 actions)

Process the ordered batch.results array

SnippetTYPESCRIPT
// Use browser-batch to execute multiple operations in one round-trip
const batch = await callTool("browser-batch", {
  actions: [
    { tool: "browser-navigate", params: { action: "goto", url: "https://site-a.com" } },
    { tool: "browser-snapshot", params: { selector: "main", excludeDecorative: true } },
    { tool: "browser-extract", params: { property: "article" } },
  ],
});

// batch.results[0] → navigation confirmation
// batch.results[1] → filtered snapshot
// batch.results[2] → extracted content

Efficient Multi-Page Crawling

Block unnecessary resources and crawl multiple pages for bulk content extraction.

Steps

Set up route interception to block images, fonts, and CSS

Navigate to the starting page

Use browser-crawl with an extraction expression

SnippetTYPESCRIPT
// Block images and stylesheets to speed up page loads
await callTool("browser-route", {
  pattern: "**/*.{png,jpg,gif,svg,css,woff,woff2}",
  action: "abort",
});

// Navigate and extract — pages load faster without media
await callTool("browser-navigate", {
  action: "goto",
  url: "https://example.com/articles",
});

// Crawl with resource blocking built in
const results = await callTool("browser-crawl", {
  urls: ["https://example.com/articles"],
  enqueueStrategy: "same-hostname",
  maxRequestsPerCrawl: 50,
  blockedResources: ["image", "stylesheet", "font", "media"],
  expression: "document.querySelector('article')?.innerText",
});

Mobile Device Testing

Set viewport size, user agent, and network throttling to test responsive design and performance.

Steps

Resize viewport to mobile dimensions with browser-resize

Set user agent and locale with browser-emulate

Apply network throttling with custom throughput and latency values

Navigate and capture a full-page screenshot

Collect performance metrics

SnippetTYPESCRIPT
// 1. Set mobile viewport size
await callTool("browser-resize", {
  width: 390,
  height: 844,
});

// 2. Set mobile user agent and locale
await callTool("browser-emulate", {
  userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15",
  locale: "en-US",
  colorScheme: "light",
});

// 3. Simulate slow network conditions
await callTool("browser-throttle", {
  downloadThroughput: 50000,    // 50 KB/s (slow 3G)
  uploadThroughput: 25000,      // 25 KB/s
  latency: 2000,                // 2s RTT
});

// 4. Navigate and screenshot for visual comparison
await callTool("browser-navigate", { action: "goto", url: "https://example.com");
const screenshot = await callTool("browser-screenshot", {
  target: "page",
});

// 5. Check performance metrics
const metrics = await callTool("browser-metrics");
// → { domContentLoaded, domInteractive, firstContentfulPaint, firstPaint, loadComplete }

File & Clipboard Operations

Handle file downloads, attachments, and clipboard operations in automated workflows.

Steps

Use browser-download to wait for and capture downloads

Use browser-attach to attach files to <input type='file'> elements

Use browser-evaluate for clipboard access

SnippetTYPESCRIPT
// 1. Set up clipboard read access
await callTool("browser-evaluate", {
  expression: "await navigator.clipboard.readText()",
});

// 2. Click a download button and check downloads
await callTool("browser-interact", {
  action: "click",
  elementRef: "@e25",            // "Download PDF" button
});
const downloads = await callTool("browser-download", {
  action: "list",          // list all downloads
});

// 3. Attach a file to a file input
await callTool("browser-attach", {
  selector: "input[type=file]",
  files: ["/path/to/document.pdf"],
});

Connector reference

Verified against the registered connector handler surfaces so browser, canvas, extension, and payment appear as runtime surfaces and Figma as a platform adapter.

Browser65
Canvas5
Figma71
Payment5
Extension5

Browser

mcp.scout.i.ng/browser

Browser automation remains the broadest connector surface, but it is one connector in the platform, not the platform itself.

Mixed MCP + CDP65 commands
Open Browser page

Hover a command to preview what it does.

Session

9

Manage browser sessions, tab attachment, and multi-agent coordination.

browser-tabs
browser-detach
browser-launch
browser-open
browser-close
browser-connect
browser-disconnect
browser-remote
browser-session

Navigation

6

Navigate between pages, manage browser history, and handle iframes.

browser-navigate
browser-search
browser-history
browser-scene
browser-frames
browser-wait

Content

9

Read and understand page content — snapshots, extraction, JavaScript evaluation.

browser-snapshot
browser-element
browser-extract
browser-evaluate
browser-pipe
browser-find
browser-inject
browser-file
browser-source

Interaction

4

Simulate user interactions — clicks, keyboard input, form filling, drag-and-drop.

browser-interact
browser-attach
browser-dialog
browser-highlight

Network

7

Monitor network traffic, intercept requests, record HAR files, manage certificates.

browser-network
browser-route
browser-unroute
browser-har
browser-security
browser-notifications
browser-websocket

Storage

4

Manage cookies, localStorage, sessionStorage, and clipboard.

browser-cookies
browser-storage
browser-clipboard
browser-bookmarks

Media

8

Capture screenshots, record screencasts, manage downloads, control media playback.

browser-screenshot
browser-pdf
browser-screencast
browser-media
browser-download
browser-transcribe
browser-still
browser-image

Debug

6

Inspect console output, measure performance, monitor DOM memory stats.

browser-console
browser-metrics
browser-memory
browser-exceptions
browser-heap
browser-trace

Emulation

6

Emulate devices, geolocation, vision deficiencies, and network/CPU throttling.

browser-emulate
browser-resize
browser-vision
browser-cpu
browser-throttle
browser-pinch

Automation

5

High-level multi-page workflows and batch operations.

browser-batch
browser-workflow
browser-crawl
browser-task
browser-animation

Styling

1

Inspect and manipulate CSS computed styles.

browser-styles

Tool parameters reference

Every registered MCP tool with its parameters and return shape, grouped by capability. Expand a group to inspect individual tools.

Session

9 tools

Manage browser sessions, tab attachment, and multi-agent coordination.

browser-tabssession

List all available browser tabs with their titles, URLs, and tab IDs. Returns @t refs used to scope subsequent tab operations.

Returns: Array of tab objects with @t refs, titles, and URLs

browser-detachsession

Detach a CDP session from a tab and clean up all associated state. Always call when done with a tab.

Returns: Confirmation of detachment

browser-launchsession

Open a new browser tab, optionally navigating to a URL immediately.

urlstringoptionaldefault: about:blankURL to open in the new tab

Returns: @t ref for the new tab

browser-opensession

Launch Chromium with a persistent user-data directory. Preserves cookies, extensions, and login state across restarts.

userDataDirstringrequiredPersistent browser profile directory path
urlstringoptionaldefault: about:blankURL to navigate to after opening the profile

Returns: Session ID with persistent profile context

browser-closesession

Close a browser tab and clean up its session. The tab is removed from the browser.

Returns: Confirmation of closure

browser-connectsession

Connect to an externally launched Chromium instance through its remote-debugging domain and port.

domainstringrequiredHostname that exposes the browser remote-debugging listener, such as 127.0.0.1 or localhost.
portnumberrequiredRemote-debugging port, such as 9222.

Returns: Connection ID and available tab refs

browser-disconnectsession

Disconnect from an externally connected browser instance.

Returns: Confirmation of disconnection

browser-remotesession

Connect to a remote Playwright browser server via WebSocket, create a tracked MCP session, and bind to an initial active page.

wsEndpointstringrequiredPlaywright browser server WebSocket endpoint to connect to (e.g., ws://127.0.0.1:3000/<token>).
timeoutnumberoptionaldefault: 30000Timeout in milliseconds for the connection attempt
maxConsoleLogsnumberoptionaldefault: 100Maximum number of console logs to track
maxNetworkRequestsnumberoptionaldefault: 100Maximum number of network requests to track
maxWebSocketConnectionsnumberoptionaldefault: 50Maximum number of WebSocket connections to track
captureBodyPatternstringoptionalGlob pattern for response body capture (e.g., '**/api/**'). Matching responses store their body up to 5 MB.

Returns: Tracked session bound to the remote browser's active page

browser-sessionsession

List, inspect, or close connector-owned browser sessions managed by the current Scout instance.

action'list' | 'status' | 'close'requiredAction: list, status (inspect one session), or close
connectionIdstringoptionalRemote browser connection ID that owns the tab (for status/close).
tabIdnumberoptionalTab identifier within the remote browser connection (for status/close).
drainNotificationsbooleanoptionaldefault: falseDrain pending notifications when inspecting a session (status action).

Returns: Session list, status details, or closure confirmation

Navigation

6 tools

Navigate between pages, manage browser history, and handle iframes.

browser-navigatenavigation

Navigate to a URL, reload, go back/forward, or set page HTML directly. Waits for the page to load before returning.

actionstringrequiredNavigation action: goto (navigate to URL), reload, back, forward, setcontent (set page HTML)
urlstringoptionalURL to navigate to (required for 'goto' action)
waitUntilstringoptionaldefault: loadWhen to consider navigation complete. Options: load, domcontentloaded, networkidle, commit
htmlstringoptionalHTML content to set (required for 'setcontent' action)

Returns: Page title and final URL after navigation

browser-searchnavigation

Perform a web search using any of 17 supported engines.

querystringrequiredSearch query text
enginestringrequiredSearch engine: google, duckduckgo, bing, brave, yahoo, yandex, startpage, and more. duckduckgo recommended (fewer captchas).

Returns: Snapshot of the search results page

browser-historynavigation

List or clear the session's browser navigation history.

action'list' | 'clear'requiredHistory action: list (show navigation history) or clear (reset history)

Returns: Navigation history entries or confirmation

browser-scenenavigation

Save and restore named scenes — the current page URL, title, and scroll position — within a session.

action'capture' | 'restore' | 'list' | 'delete'requiredAction: capture (save current page as a named scene), restore (navigate back to a scene), list, or delete
namestringoptionalUnique scene name within the session
scrollbooleanoptionaldefault: trueWhether to restore the scroll position in addition to the URL (restore action)

Returns: Scene list or navigation confirmation

browser-framesnavigation

List all iframes on the current page with their source URLs and @ref identifiers.

Returns: Array of iframe metadata

browser-waitnavigation

Wait for a specific condition before proceeding. Supports page load states, selector matching, text matching, URL matching, response matching, or a fixed delay. When more than one page scope is in play, tabRef determines which page the wait observes.

typestringrequiredWait type: load, delay, selector, text, url, or response
selectorsstring[]optionalCSS selectors to try when type='selector'. The wait succeeds when any selector resolves.
matchersArray<{ matchType: 'text' | 'glob' | 'regex'; value: string }>optionalMatchers to try when type='text', 'url', or 'response'. Each matcher provides its own matchType ('text', 'glob', or 'regex') and value.
statestringoptionalLoad state to wait for when type='load': load, domcontentloaded, or networkidle.
delayMsnumberoptionalHow long to pause in milliseconds when type='delay'.
tabRefstringoptionalTab ref that scopes the wait to a specific page. When omitted, the active tab is targeted.
timeoutnumberoptionalMaximum time to wait in milliseconds.

Returns: Confirmation when condition is met

Content

9 tools

Read and understand page content — snapshots, extraction, JavaScript evaluation.

browser-snapshotcontent

Capture the accessibility tree of the current page as a structured snapshot. Returns @e refs for all interactive elements. The primary tool for page observation. When more than one page scope is in play, tabRef determines which page the returned refs belong to.

tabRefstringoptionalTab ref that scopes the snapshot to a specific page. When omitted, the active tab is targeted. Returned @e refs belong to that tab.
selectorstringoptionalCSS selector to scope the snapshot to a specific element region
deduplicatebooleanoptionalCollapse identical repeated subtrees with a ×N indicator
disambiguatebooleanoptionalAdd [in=section] ancestor context to duplicate interactive elements
excludeDecorativebooleanoptionalRemove decorative elements (unlabeled images, aria-hidden, empty buttons)
excludeRolesstring[]optionalRoles to exclude from the snapshot (e.g., ['separator', 'presentation'])
includeRolesstring[]optionalOnly include these roles — whitelist mode (e.g., ['link', 'button'])
maxDepthnumberoptionalMaximum tree depth to include
maxElementsnumberoptionalMaximum number of elements. Use selector to narrow scope instead.
viewportOnlybooleanoptionalOnly include elements in the current viewport
flattenBeyondDepthnumberoptionalCollapse non-interactive nodes beyond this depth, promoting interactive children
groupCodeBlocksbooleanoptionalMerge sequential code lines into compact labeled blocks

Returns: YAML accessibility tree with @e refs, roles, labels, and values

browser-elementcontent

Inspect a targeted element by @ref or selector and return one semantic detail: position, size, visibility, content, attributes, styles, accessibility, state, value, or a fused layout summary.

detail'position' | 'size' | 'visibility' | 'content' | 'attributes' | 'styles' | 'accessibility' | 'state' | 'value' | 'layout'requiredSemantic detail to return: position, size, visibility, content, attributes, styles, accessibility, state, value, or layout
selectorstringoptionalElement selector: @ref (e.g., @e1) from snapshot, or CSS selector

Returns: One semantic detail object for the targeted element

browser-extractcontent

Extract data from the DOM. Supports property types: article (clean markdown via Defuddle), text, html, markdown, value, attribute, title, url, count, box, visible, enabled, checked, focused. Use @ref or CSS selector for element properties.

propertystringrequiredWhat property to retrieve: article, text, html, markdown, value, attribute, title, url, count, box, visible, enabled, checked, focused
selectorstringoptionalElement selector: @ref (e.g., @e1) from snapshot, or CSS selector. Required for element properties.
attributestringoptionalAttribute name to get (only for 'attribute' property)

Returns: Extracted property value from the DOM

browser-evaluatecontent

Execute JavaScript in the page context. Returns the evaluated result. Supports async expressions.

expressionstringrequiredJavaScript expression to evaluate

Returns: JSON-serializable result of the expression

browser-pipecontent

Evaluate JavaScript and write the result directly to a file on disk. Use for large datasets that would exceed context limits.

expressionstringrequiredJavaScript expression to evaluate
filePathstringrequiredAbsolute file path to write to
formatstringoptionaldefault: jsonOutput format: json, yaml, text, or base64
appendbooleanoptionaldefault: falseAppend to file instead of overwriting

Returns: Confirmation with byte count and file path

browser-findcontent

Search for text within the page using the browser's find bar. Returns match count and scrolls to the first match.

textstringrequiredText to find on the page
indexnumberoptionaldefault: 0Which match to scroll to (0-based)

Returns: Match count and current match index

browser-injectcontent

Inject a script or stylesheet into the page. Supports inline content, external URL, or init scripts that run on every navigation.

type'script' | 'style' | 'initscript'requiredType: script, style, or initscript (runs on every navigation)
contentstringoptionalInline content to inject
urlstringoptionalURL to inject from

Returns: Confirmation of injection

browser-filecontent

Inspect or clear the session's tracked file references (@o refs) used for uploads and other file-backed actions.

action'list' | 'get' | 'clear'requiredAction: list (tracked files), get (one file ref), or clear (reset the registry)
fileRefstringoptionalFile ref to inspect (get action)
patternstringoptionalFilter pattern for file path or name matching (list action)

Returns: Tracked file references or confirmation

browser-sourcecontent

Capture browser-readable source from the current page — full HTML, stylesheet/script sources, image asset metadata, or a specific resource URL.

kind'document' | 'styles' | 'scripts' | 'images' | 'resource'requiredWhat to capture: document, styles, scripts, images, or resource (a specific URL)
sessionRefstringrequiredSession ID
urlstringoptionalAbsolute resource URL to fetch when kind='resource'
includeContentbooleanoptionaldefault: trueInclude inline HTML, stylesheet text, script text, or fetched resource bodies when the runtime can access them
maxItemsnumberoptionaldefault: 25Maximum number of stylesheets, scripts, or images to include in list-based captures
timeoutnumberoptionaldefault: 30000Maximum time in milliseconds to wait for the source capture to complete

Returns: Captured document HTML, resource sources, or asset metadata

Interaction

4 tools

Simulate user interactions — clicks, keyboard input, form filling, drag-and-drop.

browser-interactinteraction

Perform a user interaction on a page element. Supports 16 action types including touch tap with coordinate support. @e refs from browser-snapshot and CSS selectors are both supported. When more than one page scope is in play, tabRef determines which page the action and any @e refs are scoped to.

actionstringrequiredAction type: click, clear, dblclick, drag, fill, focus, highlight, hover, check, press, scroll, select, tap, type, uncheck
selectorstringrequiredElement selector: @ref from snapshot (preferred) or CSS selector
tabRefstringoptionalTab ref that scopes the action to a specific page. When omitted, the active tab is targeted. @e refs belong to the tab that produced the snapshot.
valuestringoptionalValue for fill, type, or select actions
keystringoptionalKey to press (e.g., Enter, Tab, Control+a)
button'left' | 'right' | 'middle'optionaldefault: leftMouse button for click actions
forcebooleanoptionaldefault: falseBypass actionability checks. Use when overlays intercept clicks.
timeoutnumberoptionaldefault: 5000Maximum wait time in milliseconds
targetSelectorstringoptionalTarget selector for drag actions (required for drag only)
direction'up' | 'down' | 'left' | 'right'optionaldefault: downScroll direction for scroll actions
pixelsnumberoptionaldefault: 500Pixels to scroll
position{ x: number, y: number }optionalCoordinates for tap action: { x, y }. Taps at these coordinates instead of element center.
tapCountnumberoptionaldefault: 1Number of taps to perform (tap action only)

Returns: Updated accessibility snapshot reflecting the new page state

browser-attachinteraction

Attach one or more files to a file input element.

selectorstringrequired@ref or CSS selector of the file input
filesstring[]requiredAbsolute file paths to attach

Returns: Confirmation of file attachment

browser-dialoginteraction

Handle a browser dialog (alert, confirm, prompt, beforeunload). Accept or dismiss with optional input text.

action'accept' | 'dismiss'requiredDialog ref (@g ref) or action: accept, dismiss
promptTextstringoptionalText to enter for prompt dialogs

Returns: Confirmation of dialog handling

browser-highlightinteraction

Highlight one or more elements visually. Adds colored border/overlay for debugging or visual confirmation. Supports label, style, and auto-timeout.

action'show' | 'hide' | 'clear' | 'pulse'requiredAction: show (add highlight), hide (remove), clear (remove all), pulse (animate)
selectorstringoptionalCSS selector or @ref (required for show/hide/pulse)
stylestringoptionaldefault: borderVisual style: border, overlay, spotlight, crosshair
colorstringoptionaldefault: cyanHighlight color: red, blue, green, yellow, orange, purple, cyan
labelstringoptionalLabel to display near the element
durationnumberoptionaldefault: 1000Auto-remove timeout in milliseconds

Returns: Confirmation

Network

7 tools

Monitor network traffic, intercept requests, record HAR files, manage certificates.

browser-networknetwork

List, get, or clear captured network requests. Tracks requests with status, headers, timing, and body.

action'list' | 'get' | 'clear'requiredAction: list, get (@n ref), clear
patternstringoptionalFilter by URL pattern (glob supported). Used with list.
requestRefstringoptionalNetwork request ref (@n1) for get action

Returns: Array of network request objects or a single request detail

browser-routenetwork

Intercept and handle network requests matching a URL pattern. Supports logging, blocking, or modifying responses.

patternstringrequiredURL pattern to intercept (glob or regex, e.g., **/api/v2/**)
action'abort' | 'fulfill' | 'continue'requiredWhat to do with matched requests: abort (block), fulfill (return custom response), continue (proceed with optional modifications)
responseBodystringoptionalMock response body for modify action
responseStatusnumberoptionalMock response status for modify action

Returns: Confirmation of route registration

browser-unroutenetwork

Remove a previously registered request interception route.

patternstringrequiredURL pattern to remove interception for

Returns: Confirmation

browser-harnetwork

Start or stop recording network traffic as an HTTP Archive (HAR) file.

action'start' | 'stop'requiredAction: start or stop recording
filePathstringoptionalFile path to save the HAR file to (required for stop)

Returns: HAR data or confirmation of start/stop

browser-securitynetwork

Control SSL certificate error handling. Set ignore=true for self-signed certificates in testing environments.

ignorebooleanrequiredWhether to ignore certificate errors

Returns: Confirmation

browser-notificationsnetwork

Drain the notification queue for network events, console logs, dialogs, and other asynchronous browser events.

Returns: Array of pending events with type, timestamp, and data

browser-websocketnetwork

Track WebSocket connections and their messages. Actions: list, get, clear.

action'list' | 'get' | 'clear'requiredAction: list (all connections), get (by ref), clear
webSocketIdstringoptionalWebSocket ref (@w1) for get action
patternstringoptionalURL pattern filter for list action

Returns: WebSocket connections or message history

Storage

4 tools

Manage cookies, localStorage, sessionStorage, and clipboard.

browser-cookiesstorage

Get, set, or clear browser cookies for the current session.

action'get' | 'set' | 'clear'requiredCookie operation: get, set, or clear
cookiesCookieObject[]optionalArray of cookie objects to set (required for set action). Each cookie has name, value, and optional domain, path, httpOnly, secure, sameSite, expires, url.

Returns: Cookie value(s) or confirmation

browser-storagestorage

Interact with localStorage or sessionStorage.

action'get' | 'set' | 'remove' | 'clear' | 'keys'requiredAction: get (retrieve value), set (store value), remove (delete key), clear (remove all), keys (list all keys)
storageType'local' | 'session'optionaldefault: localStorage type: 'local' for localStorage, 'session' for sessionStorage
keystringoptionalStorage key (required for get, set, remove)
valuestringoptionalValue to store (required for set)

Returns: Storage value, key list, or confirmation

browser-clipboardstorage

Read from or write to the system clipboard.

action'read' | 'write'requiredAction: read or write
textstringoptionalText to write to clipboard (write only)

Returns: Clipboard text (read) or confirmation (write)

browser-bookmarksstorage

Manage browser bookmarks — list a folder, read the tree, search, and create, update, move, or remove bookmarks and folders.

action'list' | 'tree' | 'search' | 'get' | 'create' | 'update' | 'move' | 'remove'requiredAction: list, tree, search, get, create, update, move, or remove
titlestringoptionalBookmark or folder title (create/update actions)
urlstringoptionalBookmark URL for bookmark creation. When omitted, the operation creates a folder.
parentIdstringoptionalParent folder ID. Defaults to the root folder (create action).
bookmarkIdstringoptionalBookmark node identifier (get/update/move/remove)
querystringoptionalSearch text for bookmark lookup (search action)
indexnumberoptionalOptional position within the parent folder (create action)

Returns: Bookmark list, tree, search results, or operation confirmation

Media

8 tools

Capture screenshots, record screencasts, manage downloads, control media playback.

browser-screenshotmedia

Capture a screenshot of the viewport, full page, a specific element, or an arbitrary region. When more than one page scope is in play, tabRef determines which page the capture targets. Annotated @e refs belong to the tab that produced the corresponding snapshot.

target'screen' | 'page' | 'element' | 'clip'requiredCapture target: screen (viewport), page (full document), element (DOM element), clip (arbitrary rectangle)
tabRefstringoptionalTab ref that scopes the capture to a specific page. When omitted, the active tab is targeted. Annotated @e refs belong to the tab that produced the snapshot.
format'jpeg' | 'png'optionaldefault: jpegImage format: jpeg (smaller, lossy) or png (larger, lossless)
selectorstringoptionalElement selector: @ref or CSS selector (required for 'element' target)
xnumberoptionalClip x-coordinate in pixels (required for 'clip' target)
ynumberoptionalClip y-coordinate in pixels (required for 'clip' target)
widthnumberoptionalClip width in pixels (required for 'clip' target)
heightnumberoptionalClip height in pixels (required for 'clip' target)
annotatebooleanoptionaldefault: falseOverlay @eN ref labels on interactive elements before capture

Returns: Base64-encoded image

browser-pdfmedia

Generate a PDF of the current page.

formatstringoptionaldefault: A4Paper format: A4, Letter, Legal, Tabloid, A3, A5, A6
landscapebooleanoptionaldefault: falseLandscape orientation
printBackgroundbooleanoptionaldefault: falseInclude background graphics
pageRangesstringoptionalPage range (e.g., '1-5, 8')

Returns: Base64-encoded PDF

browser-screencastmedia

Start or stop a screen recording session. Returns video data on stop.

action'start' | 'stop'requiredAction: start or stop
filePathstringoptionalFile path to save the recording to

Returns: Confirmation (start) or video file path (stop)

browser-mediamedia

Capture a video frame at a specific timestamp, or extract audio from a media element.

selectorstringrequired@ref or CSS selector of the media element
action'frame' | 'audio'requiredAction: frame (video) or audio
timestampnumberoptionalTimestamp in seconds for frame capture

Returns: Base64-encoded frame image or audio data

browser-downloadmedia

List, get, or clear browser downloads. Track in-progress and recently completed downloads.

action'list' | 'get' | 'clear'requiredAction: list, get (@d ref), clear
downloadIdstringoptionalDownload ref (@d1) for get action

Returns: Download object(s) with status, URL, and file path

browser-transcribemedia

Transcribe speech from an audio/video element using AI. Returns a time-stamped transcript.

selectorstringrequired@ref or CSS selector of the media element

Returns: Transcript with timestamps and speaker segments

browser-stillmedia

Capture a still image from a video or media element at a specific playback timestamp. Auto-detects the first <video> element when no ref is given.

elementRefstringoptionalSnapshot video ref. Defaults to the first <video> element in the targeted page.
format'jpeg' | 'png'optionaldefault: jpegImage format for the captured frame
qualitynumberoptionalImage quality (0-100, JPEG only)
timenumberrequiredTimestamp in seconds to seek to before capturing the frame

Returns: Base64-encoded still frame image

browser-imagemedia

Read a snapshot-issued image ref (@i) and return the rendered image as a PNG or JPEG image resource.

imageRefstringrequiredSnapshot image ref (e.g., @i12). Image refs come from browser-snapshot and are separate from actionable @e refs.
format'png' | 'jpeg'requiredImage format: png (lossless) or jpeg (smaller, quality adjustable)
qualitynumberoptionaldefault: 80Image quality (0-100) for JPEG output

Returns: PNG or JPEG image resource

Debug

6 tools

Inspect console output, measure performance, monitor DOM memory stats.

browser-consoledebug

Capture or drain browser console logs. Returns entries with type, message, and timestamp. Types: log, info, warning, error.

action'enable' | 'drain'requiredAction: enable (start capture), drain (get + clear)
typestringoptionalFilter by type: log, info, warning, error, all

Returns: Array of console log entries

browser-metricsdebug

Get page performance metrics: load time, first paint, FCP, DOM interactive, DOM content loaded.

Returns: Performance timing object with all Navigation Timing metrics

browser-memorydebug

Get DOM memory counters: document count, node count, JS event listener count. Useful for detecting memory leaks.

Returns: Memory statistics object

browser-exceptionsdebug

List, get, summarize, or clear uncaught page exceptions captured for a browser session.

action'list' | 'get' | 'summarize' | 'clear'requiredAction: list, get (by ref), summarize, or clear
exceptionRefstringoptionalException ref to retrieve (get action)
limitnumberoptionalMaximum number of exceptions to return (list action). Reduces token usage for large buffers.
patternstringoptionalText pattern to filter exception messages. Plain text does substring matching; glob patterns (* ? [ ]) are supported.

Returns: Stored exception records or a summary

browser-heapdebug

Capture heap information for an attached browser session, optionally forcing garbage collection first.

collectGarbagebooleanoptionaldefault: falseForce garbage collection before taking the snapshot

Returns: Heap snapshot with memory statistics

browser-tracedebug

Control Chrome performance trace recording — start or stop, and configure which trace categories are captured.

action'start' | 'stop'requiredAction: start or stop performance trace recording
categoriesstring[]optionalChrome trace categories to record (e.g., 'devtools.timeline', 'v8.execute'). Defaults to timeline + JS execution.

Returns: Trace recording confirmation or trace data

Emulation

6 tools

Emulate devices, geolocation, vision deficiencies, and network/CPU throttling.

browser-emulateemulation

Emulate browser environment — user agent, color scheme, locale, geolocation, timezone, media type, and more.

userAgentstringoptionalOverride User-Agent string
colorSchemestringoptionalEmulate color scheme: light, dark, or no-preference
localestringoptionalEmulate locale (e.g., 'en-US')
geolocationobjectoptionalEmulate geolocation: { latitude, longitude, accuracy }
timezoneIdstringoptionalEmulate timezone (e.g., 'America/New_York')
mediastringoptionalEmulate media type: screen or print
offlinebooleanoptionaldefault: falseEmulate offline network

Returns: Confirmation of emulation settings

browser-resizeemulation

Resize the browser viewport to specific dimensions. Use for responsive design testing.

widthnumberrequiredViewport width in pixels
heightnumberrequiredViewport height in pixels

Returns: Confirmation

browser-visionemulation

Simulate a vision deficiency for accessibility testing: color blindness, blurred vision, reduced contrast.

typestringrequiredVision type: none, blurredVision, reducedContrast, achromatopsia, deuteranopia, protanopia, tritanopia

Returns: Confirmation

browser-cpuemulation

Throttle the CPU to simulate slow devices. Multiply by 4 for a mid-range mobile device.

ratenumberrequiredCPU slowdown multiplier (1 = no throttle, 4 = 4× slower)

Returns: Confirmation

browser-throttleemulation

Throttle network speed to simulate different connection conditions.

downloadThroughputnumberoptionalDownload speed in bytes/second
uploadThroughputnumberoptionalUpload speed in bytes/second
latencynumberoptionalNetwork latency in milliseconds
offlinebooleanoptionaldefault: falseSimulate offline mode

Returns: Confirmation

browser-pinchemulation

Simulate touch gestures: pinch to zoom, momentum scroll, or finger tap at specific coordinates.

gesture'pinch' | 'scroll' | 'tap'requiredGesture type: pinch, scroll, or tap
selectorstringoptionalCSS selector or @ref of the target element

Returns: Confirmation

Automation

5 tools

High-level multi-page workflows and batch operations.

browser-batchautomation

Execute multiple tool calls in a single request. Reduces round-trip overhead for sequential operations. Returns an array of results.

actionsArray<{ tool: string; params: object; id?: string }>requiredArray of tool call objects. Each has: tool (tool name), optional params (tool input), and optional id.

Returns: Batch summary with ordered results, completion status, counts, and optional haltedOnPattern/stoppedAt metadata

browser-workflowautomation

Execute a multi-step browser workflow with conditional branching. Steps can be actions (tool calls) or conditions (with then/else branches).

stepsStep[]requiredArray of workflow steps. Each step is an action ({ type: 'action', tool, params }) or a condition ({ type: 'condition', check, then, else }). Max 20 steps.
stopOnErrorbooleanoptionaldefault: trueStop executing remaining steps if an action fails

Returns: Workflow execution result with per-step outcomes

browser-crawlautomation

Crawl multiple URLs in parallel with optional link discovery, fingerprinting, session pooling, and resource blocking.

urlsstring[]requiredStarting URLs to crawl
enqueueStrategystringoptionalLink discovery strategy: same-hostname, same-domain, same-origin, all
maxRequestsPerCrawlnumberoptionaldefault: 100Maximum total pages to crawl
blockedResourcesstring[]optionalResource types to block: image, stylesheet, font, media
expressionstringoptionalJavaScript expression evaluated in each page context
filePathstringoptionalFile path to write per-page output to disk

Returns: Per-URL snapshots or expression results

browser-taskautomation

Execute a high-level natural language browser task. Scout determines the steps needed and executes them autonomously.

taskstringrequiredNatural language task description

Returns: Task execution result with steps taken

browser-animationautomation

Animate an element on the page using the Web Animations API.

selectorstringrequiredCSS selector or @ref of the element to animate
keyframesobject[]requiredCSS keyframes array (e.g., [{ opacity: 0 }, { opacity: 1 }])
optionsobjectoptionalAnimation timing options (duration, easing, fill, etc.)

Returns: Confirmation

Styling

1 tools

Inspect and manipulate CSS computed styles.

browser-stylesstyling

Get computed CSS styles for an element. Returns final rendered values after the full cascade.

selectorstringrequiredCSS selector or @ref of the target element
propertiesstring[]optionalSpecific CSS properties to retrieve (e.g., ['color', 'font-size']). Omit for all.

Returns: Record of property names to computed values

Architecture notes

The small set of system concepts that actually change how you choose a path, authenticate, and operate Scout safely.

Connectors are configured separately so each workflow only exposes the capabilities it actually needs.

The extension follows Scout's app-side tool flow rather than appearing as another public connector users install directly.

Use the extension path only when the task depends on your real tabs, cookies, or authenticated browser state; otherwise keep the workflow on isolated connector sessions.

FAQ

Common questions about setup, authentication, browser state, security, and billing.

Scout uses analytics to understand which pages are useful and where visitors drop off.

See our Privacy Policy and Terms of Service for details.