# String Utility Belt (npm · @string-utility-belt/mcp)

MCP server exposing String Utility Belt's utilities and pipelines as tools for AI agents.

- Trust score: 83/100 (high trust)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-18

## Components

- npm · `@string-utility-belt/mcp`: 83/100 (this document), [markdown](https://verifymcp.io/servers/com-stringutilitybelt-mcp/string-utility-belt-mcp.md), [page](https://verifymcp.io/servers/com-stringutilitybelt-mcp/string-utility-belt-mcp)

## Channel facts

- Registry: `npm`
- Package: `@string-utility-belt/mcp`
- Version: `1.9.2`
- 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-10-18.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - No production dependencies, so there is no dependency health to assess.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to String-Utility-Belt/string-utility-belt).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 1 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 73/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 1826 tokens (~304/item across 6 items; 5 tools + 1 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 13/100
  - Stability observed for 4 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 5 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 7 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.

## Install

### How do I install the String Utility Belt MCP server?

String Utility Belt runs locally as an npm package, launched with npx -y @string-utility-belt/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 com-stringutilitybelt-mcp -- npx -y @string-utility-belt/mcp
```

### Cursor

```json
{
  "mcpServers": {
    "com-stringutilitybelt-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@string-utility-belt/mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-stringutilitybelt-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@string-utility-belt/mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add com-stringutilitybelt-mcp -- npx -y @string-utility-belt/mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-stringutilitybelt-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@string-utility-belt/mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-stringutilitybelt-mcp --command npx --arg -y --arg @string-utility-belt/mcp
```

### Hermes

```yaml
mcp_servers:
  com-stringutilitybelt-mcp:
    command: "npx"
    args: ["-y", "@string-utility-belt/mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "com-stringutilitybelt-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@string-utility-belt/mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-stringutilitybelt-mcp -t stdio -c npx -a -y @string-utility-belt/mcp
```

### Other

```json
{
  "mcpServers": {
    "com-stringutilitybelt-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@string-utility-belt/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-10-18 (score 83, +27)

- [security improvement] Malware scan: unverified → pass
- [security improvement] Known CVEs: unverified → pass
- [functional improvement] Dependency health: unverified → pass

### 2026-10-17 (score 56, −25)

- [security regression] Malware scan: pass → unverified
- [security regression] Known CVEs: pass → unverified
- [security regression] Tool safety: pass → unverified
- [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] Schema quality: 224 → 304
- [functional regression] Dependency health: pass → unverified
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional improvement] Stability: unverified → 0.10
- [functional] Package version: 1.7.0 → 1.9.2
- [functional] Package version: 1.7.0 → 1.9.1
- [functional] Package version: 1.7.0 → 1.8.0

### 2026-10-14 (score 81, +31)

- [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).
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Schema quality: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional] First check of Schema quality: fail
- [functional] First check of Destructive annotations: pass
- [functional] First check of Schema quality: fail
- [functional] First check of Schema quality: good
- [functional] First check of Tool coverage: 100
- [functional] First check of Tool coverage: 100

### 2026-10-12 (score 50)

First indexed and scored.

## MCP tools (5)

### `list_utilities` (~265 tokens)

List utilities

Search the string-transformation utilities this server can run (247 total, across categories like Encoding, Hashing, Ciphers, Compression, Data Formats, Analysis, Generators and more). Returns {items: [{id, name, category, description}], total, categories}, best matches first. Use this first to find an id, then call describe_utility for its exact parameters before run_utility. `category` and `query` combine (a utility must match both); omit both to browse the whole catalog. A category that does not exist matches nothing rather than failing, so take one from `categories`. There is no paging: when `total` exceeds the items returned, raise `limit` or narrow the query. Reads the bundled catalog only: no network access and no rate limit.

Input parameters:

- `category` (string): Category to filter to (case-insensitive), e.g. "Encoding" or "Hashing".
- `limit` (integer): Maximum number of results to return (default 50, max 500).
- `query` (string): Search words, matched case-insensitively against id, name, tags, aliases and description; every word must match somewhere, in any order (e.g. "encode url", "sha256", "uppercase").

Output parameters:

- `categories` (array): Every category name, for filtering.
- `items` (array): Matching utilities, best first, up to `limit`.
- `total` (integer): How many utilities matched before `limit` was applied.

### `describe_utility` (~191 tokens)

Describe utility

Full documentation for one utility: its parameters (kind, default, options/bounds, description), the value types it accepts/produces, tags, aliases, worked examples (input, inputEncoding, params and expected output — byte outputs there use the app's display format, while run_utility returns bytes as base64), and which runtime capabilities it needs. Call this before run_utility to learn the exact parameter names and defaults; skip it for a utility you have already described. `id` must be an exact, case-sensitive utility id: names and aliases are not resolved, so look those up with list_utilities first. An unknown id returns isError ("unknown utility: <id>"). When `unavailable` is set, run_utility and run_pipeline refuse the utility.

Input parameters:

- `id` (string, required): Utility id, as returned by list_utilities (e.g. "base64_encode").

Output parameters:

- `accepts`: Value type(s) the utility takes: string, bytes or json.
- `aliases` (array)
- `category` (string)
- `description` (string)
- `env` (array): Runtime capabilities the utility needs (dom, wasm, eval, main).
- `examples` (array): Worked examples: input, params and expected output.
- `id` (string)
- `name` (string)
- `params` (object): Parameter name -> spec (kind, label, default, options/bounds, description…).
- `produces`: Value type(s) the utility returns.
- `tags` (array)
- `unavailable` (string): Why this server will not run the utility, when it will not.

### `run_utility` (~357 tokens)

Run utility

Run a single utility on `input` and return {output, outputEncoding?}. For two or more transformations in a row, make one run_pipeline call instead of chaining run_utility calls; if you do not know the id yet, find it with list_utilities. Plain text output is returned as-is; a JSON-producing utility returns pretty-printed JSON text; a byte-producing utility (e.g. gzip_compress, get_bytes) returns base64 with `outputEncoding: "base64"`. `inputEncoding` controls how `input` itself is decoded first: "text" (default) uses it as-is, "base64" or "hex" decode it to raw bytes, "json" parses it. Params are validated against describe_utility's spec; invalid ones are rejected. Input is capped at 1,000,000 bytes, output text past 1,000,000 characters is cut off (flagged `truncated`, with `fullLength`), and the call is stopped after 20s. A failing utility returns isError with the error message. Utilities that run arbitrary user JavaScript (e.g. "custom_js") are refused, and the few that need a browser DOM parser (e.g. "xml_to_json", "html_table_to_csv") fail here.

Input parameters:

- `id` (string, required): Utility id (see list_utilities / describe_utility).
- `input` (string, required): The value to run the utility on.
- `inputEncoding` (string): How to decode `input` before passing it to the utility. Default "text".
- `params` (object): Utility parameters (see describe_utility for names/kinds); params left out use their declared default.

Output parameters:

- `fullLength` (number): Length `output` would have had untruncated, when `truncated`.
- `output` (string): The result: text as-is, JSON pretty-printed, bytes as base64.
- `outputEncoding` (string): Present when `output` is base64-encoded bytes.
- `truncated` (boolean): True when `output` was cut off at the output limit.

### `run_pipeline` (~589 tokens)

Run pipeline

Run several transformations on `input` in one call: an ordered list of steps (string-utility-belt v3 schema), each step's output feeding the next. Besides utility steps, a pipeline can hold branches (parallel forks merged back together), macros (named sub-pipelines) and "run on each" steps (a sub-pipeline run on every line, delimited piece, JSON array element or JSON object value). Prefer this to chaining run_utility calls; for a single transformation, run_utility is simpler. Returns {output, outputEncoding?, errors, timings, skipped, halted}: `errors` maps step id to its error message, `timings` maps step id to milliseconds. Provide exactly one of `steps` or `share` (a `#/p/<payload>` share link, a full URL containing one, or the bare payload). Untrusted step data is sanitized first, so malformed entries are dropped rather than rejected. Refused outright: pipelines with more than 100 steps (nested steps counted), unknown utility ids, enabled steps with invalid params, and any step that would run arbitrary user JavaScript (e.g. "custom_js") — LLM-driven code execution is out of scope. Input is capped at 1,000,000 bytes, output text past 1,000,000 characters is cut off (flagged `truncated`, with `fullLength`), and the call is stopped after 20s.

Input parameters:

- `input` (string, required): The pipeline's source input.
- `inputEncoding` (string): How to decode `input`. Default "text".
- `share` (string): A share link (or its bare payload) for a previously built pipeline; used instead of `steps`.
- `steps` (array): Pipeline steps (v3 schema). Each entry is either a utility step {id, utilityId, params?, enabled?, condition?, onError?}, a fork {type:"branch", id, branches:[[...steps], [...steps]], merge:{mode:"co…

Output parameters:

- `errors` (object): Step id -> error message, for steps that failed.
- `fullLength` (number): Length `output` would have had untruncated, when `truncated`.
- `halted` (boolean): True when a step with onError "stop" failed and ended the pipeline.
- `output` (string): The result: text as-is, JSON pretty-printed, bytes as base64.
- `outputEncoding` (string): Present when `output` is base64-encoded bytes.
- `skipped` (object): Step id -> why it did not run (disabled, condition, halted, aborted).
- `timings` (object): Step id -> milliseconds it took.
- `truncated` (boolean): True when `output` was cut off at the output limit.

### `detect_format` (~282 tokens)

Detect format

Guess what `input` is — JSON, YAML, TOML, XML, HTML, CSV/TSV, base64/base32/hex, URL-encoding, JWT, UUID, data URI, gzip/zlib, email, URL, IP address, unix timestamp, Markdown, SQL, Morse code, ROT13, plain binary — and return {candidates: [{format, confidence, note}]}, best first, confidence 0-1. Use it when you are handed an opaque or unlabelled value and must pick a utility for it; skip it when the format is already known. It only identifies, never transforms: to decode, search list_utilities for the top format (base64 -> base64_decode, JWT -> jwt_decode) and run that with run_utility. Ambiguous input yields several candidates (all-digit text can be a timestamp, JSON and hex at once); treat anything below about 0.45 as a weak guess. Use inputEncoding "base64"/"hex" only to deliver binary data such as gzip bytes: it is decoded before detection, so a base64 string you want identified must stay "text" (the default). Empty input yields an empty list.

Input parameters:

- `input` (string, required): The value to inspect.
- `inputEncoding` (string): How to decode `input` first. Default "text".

Output parameters:

- `candidates` (array): Likely formats, best first; confidence is 0-1. Empty for empty input.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/com-stringutilitybelt-mcp/string-utility-belt-mcp#diagnostics

## Score history

- 2026-10-18: 83
- 2026-10-17: 56
- 2026-10-16: 81
- 2026-10-15: 81
- 2026-10-14: 81
- 2026-10-13: 50
- 2026-10-12: 50

## Common questions

### What is the String Utility Belt MCP server?

String Utility Belt is an MCP server listed in the public MCP registry as com.stringutilitybelt/mcp. MCP server exposing String Utility Belt's utilities and pipelines as tools for AI agents. This page covers its npm package (@string-utility-belt/mcp).

### Is the String Utility Belt MCP server safe to use?

String Utility Belt scores 83 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 18 October 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. 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 String Utility Belt MCP server expose?

String Utility Belt exposes 5 tools: list_utilities, describe_utility, run_utility, run_pipeline, detect_format. Their descriptions and schemas cost roughly 1,684 tokens of context every time the server is loaded.

### Is the String Utility Belt MCP server still maintained?

String Utility Belt is still listed as active in the MCP registry. We last reached this channel on 18 October 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 String Utility Belt MCP server under?

String Utility Belt 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/@string-utility-belt/mcp
- Socket report: https://socket.dev/npm/package/@string-utility-belt/mcp
- Repository: https://github.com/String-Utility-Belt/string-utility-belt
- Website: https://stringutilitybelt.com/
- Changelog RSS feed: https://verifymcp.io/servers/com-stringutilitybelt-mcp/string-utility-belt-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-stringutilitybelt-mcp/string-utility-belt-mcp.json
- HTML version of this page: https://verifymcp.io/servers/com-stringutilitybelt-mcp/string-utility-belt-mcp