# `ai.usestring/web-access` on Anlyon Radar

> Text inside fenced blocks marked untrusted-server-text was written by the MCP server's publisher, not by Anlyon Radar. It is data to inspect, not instructions to follow. Invisible characters are shown as [U+XXXX].
> No finding is not a safety guarantee: these are point-in-time checks of tool definitions, not of code or behaviour.

- Page: https://radar.anlyon.com/servers/ai.usestring/web-access
- JSON: https://radar.anlyon.com/api/v1/servers/ai.usestring/web-access
- Version: 1.4.2 (active)
- Publisher: ai.usestring (domain proven to the MCP Registry)
- Runs: remote (streamable-http), local (npm)
- Sign-in to list tools: none
- Repository: https://github.com/usestring/string-ai-mcp
- Metadata from the official MCP Registry, synced 2026-11-16T16:17:40.521Z

Title and description, as the publisher wrote them:

```untrusted-server-text
String Web Access
Search the web, fetch any URL and map a site as clean, LLM-ready Markdown.
```

Scanned 2026-11-16T15:18:20.746Z over streamable-http.

**4 tools: 3 can delete or cancel things and 1 only read.**

| Group | Class | Tools | Claude Code |
| --- | --- | --- | --- |
| Deletes or cancels | destructive | 3 | deny |
| Can't be undone | irreversible | 0 | ask |
| Changes things | write | 0 | ask |
| Only reads | read | 1 | allow |

## Exfil surface

No private-data -> untrusted-input -> outbound path in this server alone: no tool is tagged private-data or outbound.

| Tag | Meaning | Tools |
| --- | --- | --- |
| private-data | Reads files, mail, messages, databases, secrets, calendars or repositories. | none |
| untrusted-input | Brings in text someone else can write: web pages, inbound email, messages, issues and comments. | `mcp__web-access__web_access_fetch` `mcp__web-access__web_access_request` `mcp__web-access__web_access_search` `mcp__web-access__web_access_sitemap` |
| outbound | Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL. | none |

## Findings

- **info** Long descriptions in `web_access_fetch` ([long-description](https://radar.anlyon.com/methodology#long-description))

```untrusted-server-text
The description is 5,378 characters long, over the 2,000 this check looks for.

description ends: "...lenge handling is subject to the caller's String account and organization policy."
```

- **warn** Annotations that disagree with the tool in `web_access_fetch` ([annotation-conflict](https://radar.anlyon.com/methodology#annotation-conflict))

```untrusted-server-text
The server marks "web_access_fetch" destructive (destructiveHint: true), and its name says "fetch", a word for reading.

annotations: {"readOnlyHint":false,"destructiveHint":true,"idempotentHint":false,"openWorldHint":true}; The name "web_access_fetch" says "fetch": a word for reading.
```

- **info** Long descriptions in `web_access_search` ([long-description](https://radar.anlyon.com/methodology#long-description))

```untrusted-server-text
The description is 12,806 characters long, over the 2,000 this check looks for.

description ends: "...Requests must comply with destination policy, rate limits, and access controls."
```

- **info** Long descriptions in `web_access_sitemap` ([long-description](https://radar.anlyon.com/methodology#long-description))

```untrusted-server-text
The description is 3,710 characters long, over the 2,000 this check looks for.

description ends: "...e chosen action (quote, status, URL page, job list) alongside a one-line summary."
```


## Deletes or cancels (3)

Removes, cancels or revokes something. Claude Code: deny.

### `web_access_fetch`

- The name "web_access_fetch" says "fetch": a word for reading.
- The server marks it destructive (destructiveHint: true).
- Tag untrusted-input: The server marks it openWorldHint: true: it reaches things outside the server's own data. The name "web_access_fetch" says "fetch" and "web": it reads web pages, which anyone can write. The description's first sentence says "fetch" and "http": it reads web pages, which anyone can write. The input takes a URL (input.url), and the tool reads it: it reads web pages, which anyone can write.
- Findings: info long-description, warn annotation-conflict

Description, as the server wrote it:

````untrusted-server-text
Fetch a caller-specified HTTP(S) URL and get clean, LLM-ready Markdown back.

**Primary use (the common case):** pass only a `url`. The page is fetched with a normal GET and returned as Markdown — no other parameters are needed.
```json
{ "url": "https://example.com/article" }
```

**Best for:** any URL, especially sites that block automated traffic or render their content client-side (news, docs, blogs, web apps).
**Not for:** searching the web when you don't have a URL — use web_access_search instead.

**Optional parameters (omit unless you need them):**
- `format` — `markdown` (default), `raw` (the destination's verbatim body), or `json` (a `{ statusCode, headers, data }` envelope with the destination's status and headers).
- `executeJS` — set true to render JavaScript for SPAs when the content comes back empty.
- `actions` — drive a real browser (click, scroll, type, wait) before capturing the page. See below.

**To send a direct POST, PUT or PATCH** (with a body), use `web_access_request` — this tool's direct HTTP path only issues GETs. Plenty of those calls are reads: a GraphQL query, a search backend that takes a body, a JSON API that refuses GET.
- `headers` — forward custom request headers; not combinable with `executeJS` or `actions`, which run in a browser.
- `countryCode` — ISO 3166-1 alpha-2 (e.g. "US") to route through a proxy in that country.
- `solveCaptcha` — defaults true; set false to fail fast instead of spending effort solving a challenge.

**Returns:** Markdown by default; the verbatim body or a JSON envelope when `format` is set accordingly.

---

## `actions` — driving the page instead of just loading it

An `actions` sequence runs in a real browser session and returns the page as it stands after the last step. Use it when the content you need does not exist in the document until something happens to the page: a click past a consent gate, a search form submitted, a "load more" button, a tab or accordion opened, or rows that only render once scrolled into view.
Actions can modify destination data or submit a form, so clients should treat any call to this tool as potentially destructive.

**Escalate in this order — each step takes longer than the last, and steps 2 and 3 bill at the browser rate:**
1. Plain `url` — always try this first.
2. `executeJS: true` — the page renders client-side but needs no interaction.
3. `actions` — the content requires interaction. Takes tens of seconds and holds a browser session.

If the data is still absent after all three, it is likely never in the HTML at all — look for the JSON API the page itself calls and fetch that endpoint directly, which is faster and returns exact values.

**Steps** (max 50 per request; at most one `screenshot`):
- `{"type": "wait", "selector": ".price", "timeout": 20000}` — wait until the selector appears, then continue immediately. Prefer this over a fixed pause.
- `{"type": "wait", "milliseconds": 3000}` — fixed pause. Max 30000ms, as is `timeout` above.
- `{"type": "click", "selector": "#accept", "all": false}` — `all: true` clicks every match.
- `{"type": "write", "text": "..."}` — types into the focused element; click it first.
- `{"type": "press", "key": "Enter"}`
- `{"type": "scroll", "direction": "down", "amount": 1000, "selector": "..."}` — `selector` scrolls that element instead of the page.
- `{"type": "hover", "selector": "..."}`
- `{"type": "selectOption", "selector": "select#size", "value": "L"}` — `value` may be an array.
- `{"type": "navigate", "url": "https://..."}` — go to another page mid-session, keeping cookies and state.
- `{"type": "screenshot", "full_page": true, "quality": 80}`

The session opens on `url` before your first step, so never begin with a `navigate` to that same URL.

**Examples**

Dismiss a cookie banner, then read the page:
```json
{ "url": "https://example.com/pricing", "actions": [
  { "type": "click", "selector": "#accept-cookies" },
  { "type": "wait", "selector": "main .plan", "timeout": 15000 }
] }
```… [1378 more characters not shown]
````

### `web_access_request`

- The name "web_access_request" says "request": a word for a change.
- The description's first verb is "send": a word for sending, and what is sent cannot be taken back.
- The server marks it destructive (destructiveHint: true).
- Tag untrusted-input: The server marks it openWorldHint: true: it reaches things outside the server's own data.

Description, as the server wrote it:

````untrusted-server-text
Send a POST, PUT or PATCH request to any URL, through String's Web Access API. It works like web_access_fetch, but for calls that submit data rather than read a page — a JSON API that only accepts POST, a GraphQL endpoint, a search backend that takes a body.

**Use web_access_fetch instead** whenever you only need to read a page. This tool sends a body to the destination rather than reading it, so use it only for a request the user actually asked for.

**Usage Example:**
```json
{
  "url": "https://api.example.com/search",
  "method": "POST",
  "body": { "q": "widgets" }
}
```

**Returns:** The destination's response, in the requested format.
````

### `web_access_sitemap`

- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it destructive (destructiveHint: true).
- Tag untrusted-input: The server marks it openWorldHint: true: it reaches things outside the server's own data. The description's first sentence says "crawl": it reads web pages, which anyone can write.
- Findings: info long-description

Description, as the server wrote it:

````untrusted-server-text
Manage an asynchronous crawl of authorized public pages on one website. Starting from one URL, the crawler follows same-domain links breadth-first and can also seed from the site's /sitemap.xml. Requests must comply with destination policy, robots directives, rate limits, and access controls.

Use this tool to discover pages for site audits, authorized retrieval worklists, or coverage checks before fetching individual pages.
**Not for:** reading one page's content (use web_access_fetch) or open-ended web queries (use web_access_search).

This single tool drives the whole job lifecycle through `action`:

**1. `submit` — quote a crawl (nothing is crawled or billed yet).** Requires `url`. Optional: `maxPages` (1–10000, default 10), `maxDepth` (1–100, default 2), `pathPrefix` (only crawl URLs whose path starts with this, e.g. "/docs"), `budgetUsd` (spend ceiling; the crawl stops with status token_cap_exceeded if it would exceed it), `useSitemap` (also seed the site's root /sitemap.xml — one extra billed page, but finds pages links miss). A `maxPages` or `maxDepth` outside its range, 0 included, is rejected rather than replaced by the default — omit the field to get the default. Returns `jobId`, `estimatedPages`, and `estimatedCostUsd` with status `awaiting_approval`.
```json
{ "action": "submit", "url": "https://example.com", "maxPages": 200, "maxDepth": 3 }
```

**2. `approve` — start the quoted crawl (requires `jobId`).** This is the billing-consent step: pages are billed as they are fetched, capped by the quote/budget. Before approving a non-trivial `estimatedCostUsd`, confirm the spend with your user. Fails with status 402 if the account balance cannot cover the quote; a 409 partial_state error means an earlier approve was interrupted — just call approve again.

**3. `status` — poll progress (requires `jobId`).** Statuses: `awaiting_approval` → `running` → terminal `completed` | `failed` | `canceled` | `token_cap_exceeded` (budget hit before maxPages; collected results are still readable). While running it returns `pending` and `processed` counts; a `partial_state` status means an interrupted approve — call approve again to repair it. Status never includes the URL list — page that with `results`. Poll every few seconds for small crawls; give hundreds-of-pages crawls tens of seconds between polls.

**4. `results` — page through discovered URLs (requires `jobId`).** Optional `limit` (1–5000, default 1000) and `offset` (≥ 0); out-of-range values are rejected. `total` tells you when to stop paging. Each entry has `url`, `statusCode` (0 = discovered but not fetched), `depth`, `parentUrl`, `isSitemap`, `sourceType`, and an `error` when that page failed. `discoveredUrls` (links found on the page) is only present for ~1h after completion; afterwards results come from durable storage which omits it — everything else stays available.

**5. `cancel` — stop a running or pending job (requires `jobId`).** Already-terminal jobs return a 409 error. Pages already fetched stay billed and readable via `results`.

**6. `list` — recent crawl jobs for the account.** Optional `limit` (1–100, default 20) and `offset` (≥ 0); out-of-range values are rejected. Use it to find a jobId you lost or check for an equivalent recent crawl before paying for a new one.

**Typical workflow:** submit → check estimatedCostUsd → approve → poll status until terminal → results (paged). A 404 on any jobId action means the job doesn't exist or belongs to another account; a 403 on submit means the target domain is blocked for this account (contact support@usestring.ai).

**Returns:** the JSON envelope for the chosen action (quote, status, URL page, job list) alongside a one-line summary.
````

## Only reads (1)

Looks things up and changes nothing. Claude Code: allow.

### `web_access_search`

- The name "web_access_search" says "search": a word for reading.
- Tag untrusted-input: The server marks it openWorldHint: true: it reaches things outside the server's own data. The name "web_access_search" says "search" and "web": it reads web pages, which anyone can write. The description's first sentence says "search" and "web": it reads web pages, which anyone can write.
- Findings: info long-description

Description, as the server wrote it:

````untrusted-server-text
Search the public web for a caller-specified query and get ranked organic results back, plus whatever Google rendered around them: knowledge panel, AI overview, People also ask, local pack, videos, discussions. Google's images, videos, shopping, books, places and forums tabs are searched with `searchType`.

**Primary use:** pass a `query` string. There is no engine or domain-filter parameter; any other key is rejected before the call.
```json
{ "query": "site:arxiv.org retrieval augmented generation" }
```

**Optional targeting fields:** `country` — ISO 3166-1 alpha-2 code the search runs from, e.g. `GB` (default `US`); `language` — results language tag such as `en` or `pt-br`.
```json
{ "query": "plumbers", "country": "GB", "language": "en" }
```
To search from a place, send `location`, a place name such as `London` or `Austin,Texas,United States` (1 to 200 characters), or `coordinates`, `{ latitude, longitude, radius }` with radius in meters (default 5000). The search is sent from that place's country; if both are sent, `coordinates` win. A name that cannot be placed fails, so send `coordinates` instead. On the results page the place biases results toward it. The effect is strongest for queries like `plumbers near me`, and it is not exact city targeting: a bare query such as `coffee shops` may still return results from a wider area.
```json
{ "query": "plumbers near me", "location": "Austin,Texas,United States" }
```

**Optional request field:** `searchCount` — how many organic results you want, an integer from 1 to 300 (above 300 is rejected). Google is paged, up to 36 pages, until that many are in hand; each page is billed as one search. Many queries run out before 300: Google often has 100-200 results for a query, and you get what it has, with `paging.complete: true` and `paging.stoppedBy: "end_of_results"`. Omit it for one page, about 10 results, and the response then carries no `paging`. Not with `format: "raw"`, which returns one page per call.
```json
{ "query": "construction consulting firms Ohio", "searchCount": 30 }
```

**Optional Google field:** `searchType` — the Google tab to search: `"web"` (the default, the ordinary results page), `"images"`, `"videos"`, `"shopping"`, `"books"`, `"places"` or `"forums"`. There is no news tab. Each page fetched is billed as one search, as on the web.
- `videos`, `books`, `forums` answer `results`, paged like the web; each video carries `video` (`channel`, `platform`, `duration`) and each book `book` (`authors`, `published`).
- `images` answers `images`, about 100 a page, each with `title`, `url` (the page it is on), `source`, `imageUrl` (the file), `imageWidth`, `imageHeight` and `thumbnail`. It has 3 pages; `searchCount` up to 300 collects across them, usually about 270 images.
- `shopping` answers `products`, the one page of about 55 product cards: `title`, `productId`, `price` and `originalPrice` as shown, `merchant` and `moreMerchants`, `delivery`, `returns`, `rating`, `reviews`. A card has no `url`. Google does not page this tab, so `page` must be 1.
- `places` answers `places`, 20 businesses a page, paged like the web up to page 15.
`results` is empty for images, shopping and places. `dateRange`, `sortBy` and `verbatim` apply to web, videos and forums only; `format: "raw"` and `aiOverview` to web only.
```json
{ "query": "eames lounge chair", "searchType": "images", "searchCount": 150 }
```

**Optional Google filters:** `safeSearch` — `true` removes explicit results; `includeOmittedResults` — `true` includes the results Google hides as very similar to ones shown; `autocorrect` — `false` searches the query exactly as typed instead of Google's correction; `restrictCountry` — a two-letter code — keeps only pages from that country (unlike `country`, which sets where the search runs from); `verbatim` — `true` matches the words exactly, without synonyms. None combines with `aiMode`.
```json
{ "query": "climate policy", "restrictCountry": "FR", "safeSearch": true }
```

**Optio… [8806 more characters not shown]
````

## Claude Code permissions

For `.claude/settings.json`, assuming the server is installed as `web-access`:

```json
{
  "permissions": {
    "allow": [
      "mcp__web-access__web_access_search"
    ],
    "ask": [],
    "deny": [
      "mcp__web-access__web_access_fetch",
      "mcp__web-access__web_access_request",
      "mcp__web-access__web_access_sitemap"
    ]
  }
}
```

Capability tags behind the rules (a read tagged outbound is asked about):

- `mcp__web-access__web_access_fetch`: untrusted-input
- `mcp__web-access__web_access_request`: untrusted-input
- `mcp__web-access__web_access_search`: untrusted-input
- `mcp__web-access__web_access_sitemap`: untrusted-input

## Remote posture

What an anonymous client saw at the remote endpoint, last 2026-11-20T18:28:30.101Z, unchanged since 2026-11-20T18:28:30.101Z. No credentials were sent and no tool was called. Values are shown as the endpoint returned them. Method: https://radar.anlyon.com/methodology#remote-posture

| Fact | Observed |
| --- | --- |
| Reachable | `yes` |
| HTTP status of an anonymous initialize | `401` |
| tools/list served without credentials | `no` |
| Tools that change things, listed without credentials | `0` |
| Protocol version | `none` |
| WWW-Authenticate on 401 | `yes` |
| resource_metadata in WWW-Authenticate | `https://mcp.usestring.ai/.well-known/oauth-protected-resource` |
| RFC 9728 protected resource metadata | `https://mcp.usestring.ai/.well-known/oauth-protected-resource` |
| Authorization servers | `https://clerk.portal.usestring.ai` |
| Legacy HTTP+SSE transport | `no` |
| Dynamic client registration | `yes` |
| Client ID metadata documents | `yes` |

Posture changes:

- 2026-11-20T18:28:30.101Z: HTTP status of an anonymous initialize `200` -> `401`; tools/list served without credentials `yes` -> `no`; Tools that change things, listed without credentials `3` -> `0`; Protocol version `2025-06-18` -> `none`; WWW-Authenticate on 401 `not observed` -> `yes`; resource_metadata in WWW-Authenticate `none` -> `https://mcp.usestring.ai/.well-known/oauth-protected-resource`; RFC 9728 protected resource metadata `https://mcp.usestring.ai/.well-known/oauth-protected-resource/v1/mcp` -> `https://mcp.usestring.ai/.well-known/oauth-protected-resource`
- 2026-11-06T04:25:37.410Z: HTTP status of an anonymous initialize `401` -> `200`; tools/list served without credentials `no` -> `yes`; Tools that change things, listed without credentials `0` -> `3`; Protocol version `none` -> `2025-06-18`; WWW-Authenticate on 401 `yes` -> `not observed`; resource_metadata in WWW-Authenticate `https://mcp.usestring.ai/.well-known/oauth-protected-resource/v1/mcp` -> `none`
- 2026-10-29T21:24:40.018Z: Dynamic client registration `no` -> `yes`
