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.

Payment

mcp.scout.i.ng/browser

Payment is its own connector for checkout, balances, challenge flows, transfers, and commerce-specific execution.

Mixed MCP + CDP5 commands
Open Payment page

Hover a command to preview what it does.

Payment

5

Read balances, stage challenges, run pay flows, and move funds through the payment connector.

payment-balance
payment-challenge
payment-commerce
payment-pay
payment-transfer

Tool parameters reference

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

Payment

5 tools

Check balances, inspect challenges, discover commerce metadata, pay for gated resources, and transfer assets.

payment-balancepayment

Returns wallet address and selected asset balance. Check before transfers.

assetId'usdc' | 'weth'optionalOptional wallet-backed asset identifier to inspect (usdc or weth). Defaults to the configured wallet asset for the current run.

Returns: Wallet address, selected asset balance, and asset metadata

payment-challengepayment

Inspects a resource for HTTP 402 payment challenges without spending.

urlstringrequiredURL of the resource or endpoint to inspect for payment requirements.
initRecord<string, unknown>optionalOptional fetch init options used for discovery. Defaults to a plain GET request. This request never attempts automatic payment.

Returns: Explicit payment challenge evidence and parsed challenge details

payment-commercepayment

Fetches the origin's ACP well-known document and returns advertised transports and capabilities.

urlstringrequiredAny URL on the commerce host. The inspector derives the ACP well-known endpoint from this URL's origin.

Returns: Advertised transports and capabilities, detected protocol, evidence, and response metadata

payment-paypayment

Fetches a payment-gated resource, auto-paying x402/MPP challenges on HTTP 402. Enforces maxAmount and optional policy constraints.

urlstringrequiredURL of the x402-gated resource to fetch.
maxAmountnumberrequiredMaximum asset amount the agent is allowed to spend on this request. The request is rejected before payment if the resource costs more.
assetId'usdc' | 'weth'optionalOptional wallet-backed asset identifier to use for payment (usdc or weth). Defaults to the configured wallet asset for the current run.
initRecord<string, unknown>optionalOptional fetch init options (method, headers, body). Defaults to GET.
policyobjectoptionalOptional hard payment constraints: allowlists for versions, schemes, networks, assets, and payTo recipients, plus a maxTimeoutSeconds ceiling.

Returns: The resource content after successful payment, including amountPaid, asset metadata, protocol, and settlement trace

payment-transferpayment

Transfers the selected asset to a recipient address. Amount in human-readable units.

tostringrequiredRecipient EVM address (0x-prefixed, 42 characters).
amountnumberrequiredAmount of the selected asset to transfer in human-readable units.
assetId'usdc' | 'weth'optionalOptional wallet-backed asset identifier to transfer (usdc or weth). Defaults to the configured wallet asset for the current run.
memostringoptionalOptional human-readable note attached to this transfer.

Returns: Receipt object with txHash, amount, asset, to, network, memo, and timestamp

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.