# domscout (npm · @domscout/mcp)

domscout browser API as MCP tools: screenshots, Markdown, structured data, page automation, crawls.

- Trust score: 58/100 (low)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-20

## Components

- npm · `@domscout/mcp`: 58/100 (this document), [markdown](https://verifymcp.io/servers/jkresearch8-domscout/domscout-mcp.md), [page](https://verifymcp.io/servers/jkresearch8-domscout/domscout-mcp)

## Channel facts

- Registry: `npm`
- Package: `@domscout/mcp`
- Version: `1.0.5`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-20.

- **Supply Chain Security**: 63/100
  - No malware found by supply-chain analysis.
  - Known CVEs could not be checked: the version this server declares is not published in its registry.
  - No install/post-install scripts declared.
  - Dependency health could not be checked: the version this server declares is not published in its registry.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 0 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 80/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 1870 tokens (~155/item across 12 items; 10 tools + 2 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 93/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 78% of tool parameters carry a description.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "domscout_send_feedback" implies "send" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 11 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the domscout MCP server?

domscout runs locally as an npm package, launched with npx -y @domscout/mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add jkresearch8-domscout -- npx -y @domscout/mcp
```

### Cursor

```json
{
  "mcpServers": {
    "jkresearch8-domscout": {
      "command": "npx",
      "args": [
        "-y",
        "@domscout/mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "jkresearch8-domscout": {
      "command": "npx",
      "args": [
        "-y",
        "@domscout/mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add jkresearch8-domscout -- npx -y @domscout/mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "jkresearch8-domscout": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@domscout/mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add jkresearch8-domscout --command npx --arg -y --arg @domscout/mcp
```

### Hermes

```yaml
mcp_servers:
  jkresearch8-domscout:
    command: "npx"
    args: ["-y", "@domscout/mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "jkresearch8-domscout": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@domscout/mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add jkresearch8-domscout -t stdio -c npx -a -y @domscout/mcp
```

### Other

```json
{
  "mcpServers": {
    "jkresearch8-domscout": {
      "command": "npx",
      "args": [
        "-y",
        "@domscout/mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-20 (score 58, +20)

- [security regression] Known CVEs: pass → unverified
- [security improvement] Injection markers: unverified → pass
- [security] First check of Judged manipulation: pass
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [security] Tool safety: Tool safety not yet verified: we do not have a sandbox capture of the tool definitions this version of the package serves yet.
- [security] Stability: Stability not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.
- [functional regression] Dependency health: 0.84 → unverified
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Schema quality: unverified → 100
- [functional] First check of Schema quality: fail
- [functional] First check of Schema quality: excellent
- [functional] First check of Tool coverage: 78
- [functional] First check of Schema quality: fail
- [functional] First check of Destructive annotations: 0
- [functional] Capabilities: Protocol version not yet verified: we do not have a sandbox capture of the MCP handshake this version of the package performs yet.
- [functional] Tool coverage: Tool coverage not yet verified: we do not have a sandbox capture of the tool definitions this version of the package serves yet.
- [functional] Schema quality: Schema quality not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.
- [functional] Package version: 1.0.4 → 1.0.5

### 2026-09-19 (score 38, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-09-18 (score 23)

First indexed and scored.

## MCP tools (10)

### `domscout_check_credits` (~87 tokens)

Check credit balance and pricing

Free — this call never consumes credits or quota. Returns the credit balance, this month's quota usage, the per-second rate limit, and the full price list for every capture option. Call this before a large run to budget it, and after a 429 to find out whether you were rate limited (retry in a second) or are out of credits (do not retry).

### `domscout_extract_markdown` (~334 tokens)

Read a page as clean Markdown

Costs 1 credit. Loads a page and returns its main content as clean Markdown, with the title, description, Open Graph fields, word count, an estimated token count, and a content-quality flag. This is the right tool for reading a page — it is the cheapest option and returns text rather than an image. Use domscout_capture_screenshot only when you actually need to SEE the page. Set fast:true for static pages (documentation, blogs, news, changelogs): same price, same result shape, roughly an order of magnitude faster, but it does not run JavaScript. Check meta.renderJs and meta.contentQuality in the result and retry without fast:true if the page came back thin.

Input parameters:

- `delay` (integer): Extra milliseconds to wait after load.
- `fast` (boolean): Skip the browser and read the served HTML directly. Much faster and the same price, but JavaScript does not run, so a client-rendered page may come back empty. Cannot be combined with waitForSelector…
- `lazyScroll` (boolean): Scroll the page first to trigger lazy-loaded content. Adds 1 credit. Needs a browser, so it cannot be combined with fast:true.
- `url` (string, required): The page to load. Must be http(s) and publicly reachable. Credentials in the URL (https://user:pass@host) are rejected; these tools capture as an anonymous visitor, so use the REST API directly if th…
- `waitForSelector` (string): Wait for this CSS selector to appear before capturing.

### `domscout_capture_screenshot` (~286 tokens)

Screenshot a page

Costs 1 credit for a viewport PNG/JPEG/WebP; +1 for fullPage, +1 for PDF. Returns the image itself. Use this when you need to see layout, styling, or a visual state — for reading text, domscout_extract_markdown is cheaper and more useful.

Input parameters:

- `delay` (integer): Extra milliseconds to wait after load.
- `devicePreset` (string): Preset viewport and device characteristics. Overrides width/height when set.
- `format` (string): PDF requires a Pro plan or above.
- `fullPage` (boolean): Capture the whole scrollable page. Requires Pro or above. Adds 1 credit.
- `height` (integer): Viewport height in CSS pixels.
- `hideSelectors` (array): Elements to hide before capturing, e.g. cookie banners.
- `quality` (integer): JPEG/WebP quality.
- `selector` (string): Capture only this element.
- `url` (string, required): The page to load. Must be http(s) and publicly reachable. Credentials in the URL (https://user:pass@host) are rejected; these tools capture as an anonymous visitor, so use the REST API directly if th…
- `waitForSelector` (string): Wait for this CSS selector to appear before capturing.
- `width` (integer): Viewport width in CSS pixels.

### `domscout_extract_data` (~206 tokens)

Extract structured data from a page

Costs 2 credits. Pulls named fields off a page using CSS selectors and returns typed JSON. Each field reports found/missing/invalid_selector separately, so a partial result tells you which selector was wrong rather than failing the whole call. Requires Pro or above.

Input parameters:

- `delay` (integer): Extra milliseconds to wait after load.
- `fields` (object, required): Field name → { selector, type, attribute?, all? }. type is one of text, number, boolean, attribute, html, url, list. Set all:true to collect every match instead of the first. At most 100 fields.
- `url` (string, required): The page to load. Must be http(s) and publicly reachable. Credentials in the URL (https://user:pass@host) are rejected; these tools capture as an anonymous visitor, so use the REST API directly if th…
- `waitForSelector` (string): Wait for this CSS selector to appear before capturing.

### `domscout_inspect_page` (~175 tokens)

Get the interactive structure of a page

Costs 2 credits. Returns a semantic snapshot: the accessibility tree, the interactive elements, and a selector for each. Use this before domscout_automate_page to find out what is on the page and what to target. Requires Pro or above.

Input parameters:

- `delay` (integer): Extra milliseconds to wait after load.
- `detail` (string): "full" is slower and always returns asynchronously.
- `maxNodes` (integer)
- `url` (string, required): The page to load. Must be http(s) and publicly reachable. Credentials in the URL (https://user:pass@host) are rejected; these tools capture as an anonymous visitor, so use the REST API directly if th…
- `waitForSelector` (string): Wait for this CSS selector to appear before capturing.

### `domscout_automate_page` (~191 tokens)

Click, type, and navigate on a page, then capture the result

Costs 1 credit, +1 if more than 10 steps. Runs a sequence of actions — click, type, select, scroll, wait, navigate, pressKey, assert — and returns the final page plus a per-step pass/fail report. Call domscout_inspect_page first to find selectors. Requires Pro or above. The whole sequence shares a 24-second budget.

Input parameters:

- `actions` (array, required): Up to 25 steps, run in order.
- `extractMarkdown` (boolean): Return the final page as Markdown.
- `screenshot` (boolean): Return an image of the final state.
- `url` (string, required): The page to load. Must be http(s) and publicly reachable. Credentials in the URL (https://user:pass@host) are rejected; these tools capture as an anonymous visitor, so use the REST API directly if th…

### `domscout_crawl_site` (~169 tokens)

Crawl a set of pages under an allowlist

Costs 1 credit per page crawled — submitting the crawl itself is free. Returns a job ID immediately — poll it with domscout_get_job. Always respects robots.txt (this cannot be disabled), caps at 500 pages and depth 5, and requires an explicit HTTPS allowedOrigins list. Requires a Business plan or above.

Input parameters:

- `allowedOrigins` (array, required): Bare https origins the crawl may visit, e.g. "https://example.com". Must include the seed origin.
- `excludePatterns` (array)
- `extractMarkdown` (boolean): Capture each page as Markdown.
- `includePatterns` (array)
- `maxDepth` (integer)
- `maxPages` (integer)
- `seedUrl` (string, required): Where to start. Must be https.

### `domscout_get_job` (~113 tokens)

Check a durable job, batch, or crawl

Free — this call never consumes credits or quota. Poll a job ID returned by a crawl, a batch, or an auto-promoted capture. Status is one of pending, processing, retrying, done, error, cancel_requested, cancelled. Polling is free, so poll as often as you like — but the per-second rate limit still applies.

Input parameters:

- `jobId` (string, required): The job ID.
- `kind` (string): Which endpoint to poll. Use "crawl" for a crawl job.

### `domscout_cancel_job` (~50 tokens)

Cancel a running job

Free — this call never consumes credits or quota. Cooperatively cancels a durable job, batch, or crawl. Work already in flight may still complete.

Input parameters:

- `jobId` (string, required)

### `domscout_send_feedback` (~196 tokens)

Tell the domscout team about a problem or a gap

Free — this call never consumes credits or quota. — and it will never be charged, by design. Use this whenever something about this API got in your way: an error you could not act on, a parameter that did not behave as documented, a capability you needed and could not find, or a result that was wrong. Include the requestId from a failed call and the team sees exactly what happened on their side. A human reads these. Do not include API keys or other secrets.

Input parameters:

- `actual` (string)
- `endpoint` (string): Which tool or endpoint, e.g. "domscout_extract_data".
- `expected` (string)
- `message` (string, required): What happened, or what would have helped.
- `requestId` (string): The requestId from the call this is about, if there was one.
- `severity` (string)
- `type` (string)

## Diagnostics

Captured diagnostic sections: Provenance. The full working is on the page: https://verifymcp.io/servers/jkresearch8-domscout/domscout-mcp#diagnostics

## Score history

- 2026-09-20: 58
- 2026-09-19: 38
- 2026-09-18: 23

## Common questions

### What is the domscout MCP server?

domscout is an MCP server listed in the public MCP registry as io.github.jkresearch8/domscout. domscout browser API as MCP tools: screenshots, Markdown, structured data, page automation, crawls. This page covers its npm package (@domscout/mcp).

### Is the domscout MCP server safe to use?

domscout scores 58 out of 100 on VerifyMCP. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the domscout MCP server expose?

domscout exposes 10 tools: domscout_check_credits, domscout_extract_markdown, domscout_capture_screenshot, domscout_extract_data, domscout_inspect_page, and 5 more. Their descriptions and schemas cost roughly 1,807 tokens of context every time the server is loaded.

### Is the domscout MCP server still maintained?

domscout is still listed as active in the MCP registry. We last reached this channel on 20 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the domscout MCP server under?

domscout declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/@domscout/mcp
- Socket report: https://socket.dev/npm/package/@domscout/mcp
- Repository: https://github.com/jkresearch8/domscout-mcp
- Website: https://www.domscout.io/docs/mcp
- Changelog RSS feed: https://verifymcp.io/servers/jkresearch8-domscout/domscout-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/jkresearch8-domscout/domscout-mcp.json
- HTML version of this page: https://verifymcp.io/servers/jkresearch8-domscout/domscout-mcp