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.

Extension

mcp.scout.i.ng/browser

Sideload and automate an unpacked Chrome extension — launch, open its UI pages, evaluate the background service worker, read/write storage, and reload. Built for extension development workflows.

MCP-first5 commands
Open Extension page

Hover a command to preview what it does.

Extension

5

Sideload an extension, open its pages, drive the background worker, manage storage, and reload.

extension-launch
extension-open
extension-background
extension-reload
extension-storage

Tool parameters reference

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

Extension

5 tools

Sideload an extension, open its pages, drive the background worker, manage storage, and reload.

extension-launchsession

Launch Chromium with an unpacked extension via --load-extension. Returns sessionRef and extensionId.

extensionPathstringrequiredAbsolute path to the unpacked extension directory. Must contain a manifest.json.
userDataDirstringrequiredPersistent browser profile directory used to launch the extension. Use a dedicated automation profile, not your everyday browser profile.
headlessbooleanoptionaldefault: falseWhether to run the browser headlessly. Defaults to false because extension service workers and popups require a non-old-headless environment.
urlstringoptionalURL to navigate to after launch. Defaults to about:blank.
waitUntil'commit' | 'domcontentloaded' | 'load' | 'networkidle'optionaldefault: loadNavigation completion condition (only used when url is provided): commit, domcontentloaded, load, networkidle
timeoutnumberoptionaldefault: 30000Maximum time in milliseconds to wait for the browser to launch and the extension to initialize its background context.
windowSize{ height: number, width: number } | nulloptionalInitial browser window dimensions ({ height, width }). Null uses Chromium's default sizing.
chromiumFlagsstring[]optionalAdditional Chromium launch flags.

Returns: sessionRef and extensionId

extension-openinteraction

Open an extension HTML page (popup, sidepanel, options) in a new tab. Returns a tabRef for browser-* tools.

extensionIdstringrequiredThe 32-character Chrome extension ID returned by extension-launch.
pagestringrequiredExtension HTML file to open relative to the extension root. Common values: popup.html, sidepanel.html, options.html.
waitUntil'commit' | 'domcontentloaded' | 'load' | 'networkidle'optionaldefault: loadNavigation completion condition.
timeoutnumberoptionaldefault: 15000Maximum time in milliseconds to wait for the extension page to load.

Returns: tabRef and accessibility snapshot of the extension UI

extension-backgrounddebug

Evaluate JavaScript in the extension background service worker. Full chrome.* API access with promises auto-awaited.

extensionIdstringrequiredThe 32-character Chrome extension ID returned by extension-launch.
expressionstringrequiredJavaScript expression to evaluate in the extension background context.

Returns: Serialized evaluation result

extension-reloadsession

Reload the extension via chrome.runtime.reload(). Waits for the service worker to re-register by default.

extensionIdstringrequiredThe 32-character Chrome extension ID returned by extension-launch.
waitForServiceWorkerbooleanoptionaldefault: trueAfter reloading, wait for the extension's service worker or background page to re-register before returning.
waitTimeoutnumberoptionaldefault: 10000Maximum time in milliseconds to wait for the background context to re-register after reload.

Returns: Confirmation

extension-storagestorage

Read or write chrome.storage areas (local, sync, session, managed). Supports get, set, remove, and clear.

extensionIdstringrequiredThe 32-character Chrome extension ID returned by extension-launch.
action'get' | 'set' | 'remove' | 'clear'requiredStorage action: get, set, remove, or clear.
area'local' | 'sync' | 'session' | 'managed'optionaldefault: localChrome storage area to target: local, sync, session, or managed (read-only enterprise policy storage).
keysstring[]optionalStorage keys to read (get) or delete (remove). Omit to read the full area.
dataRecord<string, unknown>optionalKey-value pairs to write. Values must be JSON-serialisable (set action).

Returns: Storage values or confirmation

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.