Skip to content

Payload Validator MCP server

com.gumballtools/payload-validatorgumballtools.comstreamable-httpv0.1.0Scanned

Validate JSON, YAML, XML and CSV with exact line/column errors and silent-corruption warnings.

5 tools: 5 only read.

Tools: 0 delete, 0 irreversible, 0 write, 5 read.
  • Reads private data · 0
  • Reads text others write · 0
  • Can send data out · 0
  • 5 findings

Tools listed without sign-in. Remote posture

With Anlyon

Decide which of this server's tools your agent can use.

  • Anlyon lists the tools and adopts none.
  • Each tool you adopt gets approvals and receipts.
  • Your agent never holds the key.
Govern this server →

A tool your agent calls directly is not routed through Anlyon and is not governed by it. Anlyon Radar only lists and labels, and these labels are the same either way.

What the Payload Validator MCP server can do

The Payload Validator MCP server is published by gumballtools.com, a domain the MCP Registry verified. It has 5 tools. Every one of them only reads: going by their definitions, none of them creates, changes, sends or deletes anything.

None of its tools reads private data, brings in text other people write, or sends data out.

The fixed checks matched 5 findings (long-description). Each one comes with the text it matched.

Its remote endpoint lists its tools without sign-in.

Last scanned Nov 17, 2026, version 0.1.0.

Tools

Grouped by what each tool does, most consequential first. Open one for its reasons and full description; descriptions are the publisher's own words.

5 tools

Only reads 5Show 5 read-only tools
  • validate_autoDetects whether a payload is JSON, YAML, XML or CSV, then validates it.1 finding

    Why it is in this group

    • The name "validate_auto" says "validate": a word for reading.

    Findings

    • Info

      The description is 2,119 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...D is fetched over the network. Payloads are validated in memory and never stored."

      What this check looks for
    Description, as the server wrote it
    Detects whether a payload is JSON, YAML, XML or CSV, then validates it. Use this when you have a blob of text and do not know what it is — a file with no extension, a clipboard paste, a response body with an unhelpful content type, or a config file whose format you would otherwise have to guess. Detection is structural and the reason is always returned, so the assumption is visible rather than hidden: a leading `<` is XML, a leading `{` or `[` is JSON, a `%YAML` directive or `key: value` lines are YAML, and a consistent delimiter count across multiple lines is CSV. JSON is checked before YAML on purpose, because JSON is a strict subset of YAML 1.2 and every JSON document would otherwise be ambiguous. If the detected format does not validate but JSON or XML does, the result is corrected and `detection.corrected` is true. Only those two can win a correction, because only they have decisive grammars — CSV will read almost any text as a valid single-column file, so "it validates as CSV" is not evidence, and allowing it would silently reinterpret broken JSON as fine. Prefer the format-specific tool when you already know the format: it skips detection and cannot be corrected out from under you. Input: `input`, the raw text. Up to 1,000,000 bytes. Returns: `valid` (no errors), `parseable` (whether a conforming parser would accept it — deliberately separate, because a duplicate key parses fine and still means two different things), a `diagnostics` array where each entry has a 1-based `line` and `column`, a stable `rule` code, a `message`, an `excerpt` showing the offending line with a caret under the column, a `fixHint`, and `blocksParse`; plus `counts` and format-specific `stats`. Rule codes are stable and safe to branch on; messages are not. Additionally `detection` with the chosen `format`, the `reason` in one sentence, and `corrected`. Safety: nothing is resolved, fetched or expanded. External XML entities are reported, never retrieved; alias bombs are detected without being expanded; no schema or DTD is fetched over the network. Payloads are validated in memory and never stored.

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • validate_csvValidates CSV text against RFC 4180 and reports ragged rows individually, with both field counts.1 finding

    Why it is in this group

    • The name "validate_csv" says "validate": a word for reading.

    Findings

    • Info

      The description is 2,576 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...D is fetched over the network. Payloads are validated in memory and never stored."

      What this check looks for
    Description, as the server wrote it
    Validates CSV text against RFC 4180 and reports ragged rows individually, with both field counts. Use this before loading a CSV, and whenever a CSV-derived number looks wrong. Do not attempt this by reading the file, and be aware that loading it successfully proves nothing. The failure that matters is the ragged row: a file where one row has six fields and the header has five loads without complaint almost everywhere — pandas pads or throws depending on the engine, Excel shifts the columns, and `split(",")` silently mis-assigns every field after the extra one. Nobody notices until a figure is wrong in a report. This reports it as "row 4813 has 6 fields; the header has 5", per row. The other half is the delimiter. A European CSV is semicolon-separated because the comma is the decimal separator; reading it as comma-separated yields one column of nonsense and no error. The delimiter is sniffed from the header — ignoring quoted regions so their contents cannot vote — and always reported, with a warning when the guess was a close call. Pass `delimiter` to remove the guess entirely. Also reports: unterminated quotes (which swallow the rest of the file into one field, which is why one typo can make thousands of rows look ragged), text after a closing quote, stray quotes in unquoted fields, duplicate column names, unnamed columns, column names with invisible leading or trailing whitespace, mixed CRLF/LF line endings, CR-only endings, and a byte order mark — which becomes part of the first column's name, so a lookup for "id" fails against a column that prints identically. Input: `input`, the raw CSV text. Optional `delimiter` (a single character) and `hasHeader` (default true; pass false and rows are compared against the first row instead, and header checks are skipped). Up to 1,000,000 bytes. Returns: `valid` (no errors), `parseable` (whether a conforming parser would accept it — deliberately separate, because a duplicate key parses fine and still means two different things), a `diagnostics` array where each entry has a 1-based `line` and `column`, a stable `rule` code, a `message`, an `excerpt` showing the offending line with a caret under the column, a `fixHint`, and `blocksParse`; plus `counts` and format-specific `stats`. Rule codes are stable and safe to branch on; messages are not. Safety: nothing is resolved, fetched or expanded. External XML entities are reported, never retrieved; alias bombs are detected without being expanded; no schema or DTD is fetched over the network. Payloads are validated in memory and never stored.

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • validate_jsonValidates a JSON document and reports every problem with an exact line and column.1 finding

    Why it is in this group

    • The name "validate_json" says "validate": a word for reading.

    Findings

    • Info

      The description is 2,380 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...D is fetched over the network. Payloads are validated in memory and never stored."

      What this check looks for
    Description, as the server wrote it
    Validates a JSON document and reports every problem with an exact line and column. Use this whenever you need to know why a JSON payload is failing, or to check a JSON document you or a user produced before sending it somewhere that will reject it. Do not do this by reading the JSON yourself. Three of the findings are invisible to inspection and to JSON.parse alike: (1) Duplicate keys. `{"port":8080,"port":9090}` is accepted by every mainstream parser, which keeps the last value and discards the first without a word. Reading it, you cannot see which one the consumer will use, because the answer differs by language. (2) Integer precision loss. `9007199254740993` parses as `9007199254740992` — quietly, because JSON numbers are IEEE-754 doubles in nearly every parser, exact only to 2^53-1. Any 64-bit ID (Twitter, Discord, most database bigints) is in the lossy range. This tool proves the loss with exact BigInt arithmetic rather than estimating it. (3) Lone surrogates. `"\ud83d"` alone is syntactically legal and cannot be encoded as UTF-8, so the document parses here and fails somewhere else entirely. It also reports, with positions: trailing commas, comments, single-quoted strings, unquoted keys, Python literals (True/None/NaN/Infinity), leading zeros, hex numbers, unescaped control characters, raw line breaks inside strings, byte order marks, and trailing content — including recognising when the input is actually NDJSON being read as one document. Input: `input`, the raw JSON text as a string. Not a parsed object — the text, because the findings are properties of the text. Up to 1,000,000 bytes. Returns: `valid` (no errors), `parseable` (whether a conforming parser would accept it — deliberately separate, because a duplicate key parses fine and still means two different things), a `diagnostics` array where each entry has a 1-based `line` and `column`, a stable `rule` code, a `message`, an `excerpt` showing the offending line with a caret under the column, a `fixHint`, and `blocksParse`; plus `counts` and format-specific `stats`. Rule codes are stable and safe to branch on; messages are not. Safety: nothing is resolved, fetched or expanded. External XML entities are reported, never retrieved; alias bombs are detected without being expanded; no schema or DTD is fetched over the network. Payloads are validated in memory and never stored.

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • validate_xmlValidates an XML document for well-formedness, namespace correctness, and the entity-based attacks that arrive as XML.1 finding

    Why it is in this group

    • The name "validate_xml" says "validate": a word for reading.

    Findings

    • Info

      The description is 2,249 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...D is fetched over the network. Payloads are validated in memory and never stored."

      What this check looks for
    Description, as the server wrote it
    Validates an XML document for well-formedness, namespace correctness, and the entity-based attacks that arrive as XML. Use this before parsing XML you received, and when an XML document is being rejected by something that will not say why. Do not eyeball this. Four classes of genuinely invalid XML are accepted by ordinary well-formedness checkers, so "it validated" does not mean what it appears to: (1) Two root elements. `<a/><b/>` is not a valid XML document; XML permits exactly one outermost element. Concatenated records hit this constantly. (2) Undeclared namespace prefixes. `<x:a>` with no `xmlns:x` is well-formed as raw XML and invalid under Namespaces in XML — so it passes a syntax check and is then rejected by XPath, XSLT, SOAP and every schema validator. (3) Undeclared entities. XML predefines only five (`&lt; &gt; &amp; &apos; &quot;`). `&nbsp;` is an HTML entity and is simply undefined in XML. (4) A bare `&`, almost always arriving inside a URL. Security findings, which are the reason to run this on input you did not write: external entity declarations (XXE — reported with the URI they point at and the remediation for Python, Java and .NET), nested entity expansion (billion laughs), parameter entities (the out-of-band XXE vehicle), external DTD references (an SSRF vector and a runtime dependency on someone else's host), and any DOCTYPE at all, since hardened parsers reject them outright. Input: `input`, the raw XML text as a string. Up to 1,000,000 bytes. Returns: `valid` (no errors), `parseable` (whether a conforming parser would accept it — deliberately separate, because a duplicate key parses fine and still means two different things), a `diagnostics` array where each entry has a 1-based `line` and `column`, a stable `rule` code, a `message`, an `excerpt` showing the offending line with a caret under the column, a `fixHint`, and `blocksParse`; plus `counts` and format-specific `stats`. Rule codes are stable and safe to branch on; messages are not. Safety: nothing is resolved, fetched or expanded. External XML entities are reported, never retrieved; alias bombs are detected without being expanded; no schema or DTD is fetched over the network. Payloads are validated in memory and never stored.

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • validate_yamlValidates a YAML document, including the values that mean different things to different YAML loaders.1 finding

    Why it is in this group

    • The name "validate_yaml" says "validate": a word for reading.

    Findings

    • Info

      The description is 2,596 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...D is fetched over the network. Payloads are validated in memory and never stored."

      What this check looks for
    Description, as the server wrote it
    Validates a YAML document, including the values that mean different things to different YAML loaders. Use this for any YAML you are about to write or have just been given — CI configs, Kubernetes manifests, docker-compose files, OpenAPI specs, Ansible playbooks. Do not reason about YAML type resolution yourself. It is the single most reliable way to be confidently wrong about a config file, because YAML 1.1 and YAML 1.2 resolve the same plain scalar to different values and real loaders disagree about which to implement — PyYAML is 1.1, Go's yaml.v3 and the yaml npm package are 1.2: - `no`, `yes`, `on`, `off`, `y`, `n` are booleans in 1.1 and strings in 1.2. A country list containing `no` loses Norway. This is known as the Norway problem. - `on:` as a KEY, as in every GitHub Actions workflow, is the boolean `true` under 1.1, so the key is not "on" at all. - `0755` is 493 under 1.1 (octal) and 755 under 1.2 (decimal). Both are numbers, so nothing looks wrong; a file mode is simply the wrong number. - `1:30` is the integer 90 under 1.1, because YAML 1.1 has base-60 integers. - A bare `2026-01-01` is a timestamp under 1.1 and a string under 1.2. Divergence is found by resolving each unquoted scalar under both spec versions and comparing, so the answer is what the parsers actually do rather than a list of words someone remembered. Quoted values are never flagged, because quoting is exactly how YAML says "this is a string". Also reports: duplicate keys, tabs used as indentation (forbidden, and invisible), non-breaking spaces used as indentation (the giveaway that YAML was copied from a web page), aliases with no anchor and anchors nothing references, merge keys (`<<`, a 1.1 extension not in 1.2 core), multi-document streams, and alias bombs. Input: `input`, the raw YAML text as a string. Up to 1,000,000 bytes. Returns: `valid` (no errors), `parseable` (whether a conforming parser would accept it — deliberately separate, because a duplicate key parses fine and still means two different things), a `diagnostics` array where each entry has a 1-based `line` and `column`, a stable `rule` code, a `message`, an `excerpt` showing the offending line with a caret under the column, a `fixHint`, and `blocksParse`; plus `counts` and format-specific `stats`. Rule codes are stable and safe to branch on; messages are not. Safety: nothing is resolved, fetched or expanded. External XML entities are reported, never retrieved; alias bombs are detected without being expanded; no schema or DTD is fetched over the network. Payloads are validated in memory and never stored.

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false

This is not a safety rating, and no finding is not a safety guarantee. The groups and findings come from fixed checks of the tool definitions the server returned on the date shown, not from its code or what it does when called. How the checks work.

Exfil surface

Which tools read private data, which read text someone else can write, and which can send data out. One of each is a path a prompt injection can use.

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

Reads private data0
Reads files, mail, messages, databases, secrets, calendars or repositories.
Reads text others write0
Brings in text someone else can write: web pages, inbound email, messages, issues and comments.
Can send data out0
Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.

Other servers in the same agent add their own tools to these paths. Audit your whole setup to see them together.

Remote posture

What anyone on the internet sees at the remote endpoint: an anonymous initialize and tools/list, and the public OAuth metadata.

Tools listed without sign-in

Looked at Nov 20, 2026, 19:26 UTC, unchanged since Oct 22, 2026. No credentials were sent and no tool was called. What is looked at.

Reachable
yes
HTTP status of an anonymous initialize
200
tools/list served without credentials
yes
Tools that change things, listed without credentials
0
Protocol version
2025-06-18
WWW-Authenticate on 401
not observed
resource_metadata in WWW-Authenticate
not observed
RFC 9728 protected resource metadata
not observed
Authorization servers
not observed
Legacy HTTP+SSE transport
no
Dynamic client registration
not observed
Client ID metadata documents
not observed

Findings

Matches of fixed checks, with the text they matched.

5 info
  • The description is 2,380 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...D is fetched over the network. Payloads are validated in memory and never stored."

    What this check looks for
  • The description is 2,596 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...D is fetched over the network. Payloads are validated in memory and never stored."

    What this check looks for
  • The description is 2,249 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...D is fetched over the network. Payloads are validated in memory and never stored."

    What this check looks for
  • The description is 2,576 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...D is fetched over the network. Payloads are validated in memory and never stored."

    What this check looks for
  • The description is 2,119 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...D is fetched over the network. Payloads are validated in memory and never stored."

    What this check looks for

History

Changes to its tool definitions and to its remote endpoint, newest first.

No change seen yet. Its tools are rescanned every day, and a remote endpoint is looked at once a week.

Install

Pinned to version 0.1.0. Values in angle brackets are yours to fill in.

claude mcp add --transport http payload-validator https://payload-validator.gumballtools.com/api/mcp
claude mcp add --transport http payload-validator https://payload-validator.gumballtools.com/api/mcp

Run in a terminal.

Claude Code permissions

Allow the reads, ask before a change or a way out, deny the deletes. Paste into .claude/settings.json.

.claude/settings.json
{
  "permissions": {
    "allow": [
      "mcp__payload-validator__validate_json",
      "mcp__payload-validator__validate_yaml",
      "mcp__payload-validator__validate_xml",
      "mcp__payload-validator__validate_csv",
      "mcp__payload-validator__validate_auto"
    ],
    "ask": [],
    "deny": []
  }
}

Tools that only read are allowed, tools that change things ask first, tools that delete or cancel are denied. A read that can send data out (it takes a URL, say) asks first too. It assumes the server is installed as payload-validator. Review it before you use it.

Pin

Keep the decision: fail CI when the tools change, follow every change, or show a badge.

Pin in CI

Fail a build when the tools you reviewed are not the tools the server serves today.

curl -s "https://radar.anlyon.com/api/v1/servers/com.gumballtools/payload-validator/verify?hash=2e4ff12f870b41dc5062b26d35a80d64982a4e4b6a4409a46c81c6ac41937cd6" | jq -e '.changed == false'

Pinned hash 2e4ff12f870b, from Nov 17, 2026, 12:18 UTC.

Watch

Get told when its tools change: a new tool, a new description, a new class.

https://radar.anlyon.com/servers/com.gumballtools/payload-validator/changes.xml

An Atom feed. Works in any feed reader or Slack's RSS app.

Badge

Anlyon Radar badge for com.gumballtools/payload-validator
[![Anlyon Radar](https://radar.anlyon.com/badge/com.gumballtools/payload-validator.svg)](https://radar.anlyon.com/servers/com.gumballtools/payload-validator)

Source: MCP Registry · repository. Synced Oct 21, 2026, 17:56 UTC.

Payload Validator MCP server: questions and answers

Answered from the scan above, not from the publisher's description.

Is the Payload Validator MCP server safe?

No scan can promise that. What its definitions show: 5 tools, all of which only read, and 5 findings from fixed checks. Read-only tools can still pass private data to a model.

Can the Payload Validator MCP server delete data?

No tool is classed as destructive: going by their definitions, none of them deletes, cancels or revokes anything.

Can the Payload Validator MCP server do things that cannot be undone?

No tool is classed as irreversible: none of them sends, pays, publishes or merges, going by their definitions.

What tools does the Payload Validator MCP server have?

5 tools: 5 read. validate_json, validate_yaml, validate_xml, validate_csv and validate_auto.

Does the Payload Validator MCP server need sign-in or OAuth?

Its remote endpoint listed its tools to an anonymous client, without sign-in.

Does the Payload Validator MCP server send data to outside services?

None of its tools sends, posts or publishes, or takes a recipient, channel or URL.

Has the Payload Validator MCP server changed its tools?

Not since Anlyon Radar started tracking it. Last scanned Nov 17, 2026.