Skip to main content
Glama
presidio-hardened-x402-mcp

presidio-hardened-x402-mcp

by presidio-v

presidio-hardened-x402-mcp

PyPI version Python GitHub release License: MIT CI OpenSSF Scorecard OpenSSF Best Practices

Pre-payment safety gate for x402 — agents call screen_payment_metadata(...), check_payment_policy(...), and check_payment_replay(...) before signing, catching PII, budget overruns, and duplicate payments before metadata or money leaves the agent host.

Part of the presidio-hardened-* toolkit family. Thin MCP (Model Context Protocol) adapter over the presidio-hardened-x402 library, pinned to parent 0.14.x (presidio-hardened-x402>=0.14.0,<0.15.0), the parent's Python 3.11 line. 0.13.0 was the first parent that can record a control as NOT_EVALUATED, which signed decision evidence needs; it also includes the 0.11.1 fix for the percent-encoded PII redaction bypass, which remains a security floor.

Why this exists

x402 agentic payments routinely carry user-supplied free text — descriptions, memos, query-string parameters — straight through to merchants and facilitators. When an LLM agent generates that text, it can include PII the user never intended to share. Once the merchant logs it, retention is their decision, not yours.

This MCP server gives agents a small default-deny gate before payment leaves the agent host. Three tools expose the parent library's stable pre-payment controls: PII redaction, spending policy, and replay detection. Since 0.3.0 each decision can also be emitted as a signed payment-decision@1 record that a third party verifies offline (see Signed decision evidence). The tools are designed to compose with payment-execution and endpoint-safety MCP servers (x402station, Coinbase x402, Sardis, ...), while other parent-library surfaces — evidence-ref@1 verification of inbound evidence, the v0.9.1 SLO broker, the v0.10.0 settlement-ref@1 treasury binding, and the v0.11.0 CapabilityEnforcer — stay in the Python library unless an MCP tool explicitly wraps them later.

Related MCP server: pulsefeed-x402-mcp

Install & configure

Requires Python ≥ 3.11. Distributed on PyPI; recommended invocation via uvx (no global install).

Claude Desktop / Claude Code

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or the equivalent on your platform:

{
  "mcpServers": {
    "presidio-x402": {
      "command": "uvx",
      "args": ["presidio-hardened-x402-mcp"]
    }
  }
}

Cursor / Windsurf / Continue

Same shape — every MCP host accepts command / args / env. See your editor's MCP-server docs for the config-file path.

Environment variables

All optional. Defaults give a zero-config in-process mode with no quota, no network, and no PII storage.

Variable

Purpose

Default

PRESIDIO_X402_MCP_MODE

regex (zero-setup) or nlp (needs [nlp] extra + a spaCy model)

regex

PRESIDIO_X402_MCP_MAX_PER_CALL_USD

Max USD per single payment (policy gate)

unset → no limit

PRESIDIO_X402_MCP_DAILY_LIMIT_USD

Max USD per rolling window (policy gate)

unset → no limit

PRESIDIO_X402_MCP_PER_ENDPOINT_JSON

Per-endpoint cap, e.g. '{"api.foo.com": 5.00}'

unset

PRESIDIO_X402_MCP_WINDOW_SECONDS

Rolling window for the daily limit

86400

PRESIDIO_X402_MCP_AGENT_ID

Label written into audit records

unset

PRESIDIO_X402_MCP_REPLAY_TTL

Fingerprint cache TTL (seconds)

300

PRESIDIO_X402_MCP_REDIS_URL

Use Redis for replay state instead of in-memory

unset

PRESIDIO_X402_MCP_AUDIT_PATH

Append-only JSON-L audit log path; omit to disable

unset

PRESIDIO_X402_MCP_LOG_LEVEL

DEBUG / INFO / WARNING / ERROR

INFO

PRESIDIO_X402_MCP_REMOTE_BASE_URL

Enable HTTP-proxy mode for tool 1 — see Modes. Must be https://; plain http:// is accepted only for loopback and otherwise refuses to start

unset

PRESIDIO_X402_MCP_REMOTE_API_KEY

API key for the remote screening service

unset

PRESIDIO_X402_FINGERPRINT_KEY

32-byte hex key for cross-process replay detection

unset (per-process)

PRESIDIO_X402_CHAIN_KEY

32-byte hex key for cross-process audit-chain HMAC

unset (per-process)

PRESIDIO_X402_REQUIRE_FINGERPRINT_KEY

Fail startup if replay key is absent or invalid

unset

PRESIDIO_X402_REQUIRE_CHAIN_KEY

Fail startup if audit-chain key is absent or invalid

unset

PRESIDIO_X402_MCP_EVIDENCE_KEY_FILE

File holding the decision-signing key (preferred; wins over the env key)

unset

PRESIDIO_X402_EVIDENCE_KEY

Decision-signing key (the parent library's variable): Ed25519 private key as 64 hex chars, or an HMAC secret

unset

PRESIDIO_X402_MCP_DECISION_PATH

Append-only JSON-L file for signed payment-decision@1 records

unset

PRESIDIO_X402_MCP_EVIDENCE_ALGORITHM

ed25519 or hmac-sha256

ed25519

PRESIDIO_X402_MCP_EVIDENCE_SIGNER

Signer identity; the trust-store key verifiers look up

presidio-hardened-x402-mcp

PRESIDIO_X402_MCP_EVIDENCE_KEY_ID

Optional key id written into each record (for rotation)

unset

PRESIDIO_X402_MCP_REQUIRE_EVIDENCE_KEY

Fail startup unless signed evidence is fully configured and the key signs

unset

PRESIDIO_X402_MCP_GATE_CERTIFICATE

ikigov-assess gate-certificate@1 file(s) the payments are authorised under, os.pathsep-separated; needs the [gate] extra

unset

PRESIDIO_X402_MCP_GATE_TRUST

Trust store for the certificate issuer (and its embedded evidence signers); required with the above

unset

Generate cross-process keys with openssl rand -hex 32.

Tools

screen_payment_metadata(resource_url, description, reason, entities?)

Detects and redacts PII in payment metadata. No side effects — safe to call repeatedly.

// Input
{
  "resource_url": "https://api.foo.com/u/jane@example.com",
  "description": "monthly fee for jane@example.com",
  "reason": ""
}

// Output
{
  "redacted_resource_url": "https://api.foo.com/u/<EMAIL_ADDRESS>",
  "redacted_description": "monthly fee for <EMAIL_ADDRESS>",
  "redacted_reason": "",
  "entities_found": [
    { "entity_type": "EMAIL_ADDRESS", "field": "resource_url", "count": 1 },
    { "entity_type": "EMAIL_ADDRESS", "field": "description", "count": 1 }
  ],
  "mode": "in_process"
  // + "decision_ref": "<64 hex>" when signed decision evidence is enabled
}

entities (optional list of Presidio entity types) narrows detection to a whitelist. Field-length caps mirror the screening-api wire contract that remains stable through parent 0.7.x: resource_url ≤ 2048, description ≤ 4096, reason ≤ 4096 characters. Oversized inputs raise ValueError.

check_payment_policy(resource_url, amount_usd, prior_decision_refs?)

Spending-policy gate. Records the spend on success — call exactly once, immediately before payment. Skipping the actual payment after a successful check inflates the daily-limit ledger until the window rolls over.

The URL is screened first and only the redacted URL reaches the policy engine, so no raw URL lands in the parent's logs. Per-endpoint limits match on that redacted URL; keep PII out of configured endpoint prefixes. If screening fails, the gate denies without recording spend.

// Input
{ "resource_url": "https://api.foo.com/x", "amount_usd": 1.50 }

// Output (allowed)
{ "allowed": true }

// Output (denied — over per-call limit of $5.00)
{ "allowed": false, "reason": "...", "limit_usd": 5.00, "amount_usd": 6.00 }

With signed evidence enabled, both outputs also carry decision_ref. prior_decision_refs (optional, up to 8) links refs this server returned earlier for the same payment — typically the one from screen_payment_metadata — into the signed record; a ref this process did not issue is refused before any spend is recorded.

check_payment_replay(resource_url, pay_to, amount, currency, deadline_seconds, prior_decision_refs?)

Duplicate-payment gate via HMAC-SHA256 fingerprint of the canonical fields. Records the fingerprint on success — call exactly once, immediately before payment.

amount is a string to preserve precision. Cross-process detection requires PRESIDIO_X402_FINGERPRINT_KEY (and optionally PRESIDIO_X402_MCP_REDIS_URL); otherwise each MCP server process keeps its own in-memory store.

// Input
{
  "resource_url": "https://api.foo.com/x",
  "pay_to": "0xabc...",
  "amount": "1.50",
  "currency": "USDC",
  "deadline_seconds": 1700000000
}

// Output (first seen)
{ "is_replay": false, "fingerprint": "29aaf60f..." }

// Output (duplicate within TTL)
{ "is_replay": true, "fingerprint": "29aaf60f..." }

decision_ref and prior_decision_refs behave as for check_payment_policy.

Signed decision evidence

The audit log (PRESIDIO_X402_MCP_AUDIT_PATH) is HMAC-chained: tamper-evident to whoever holds PRESIDIO_X402_CHAIN_KEY, and to nobody else. From 0.3.0 every tool decision — allow and block alike — can also be written as a signed payment-decision@1 record, built and signed by the parent library (build_payment_decision_content, build_decision_evidence) and checked by anyone with the public key (verify_decision_ref). The audit log is still written; the records go alongside it, never instead of it.

# One-time: an Ed25519 key pair for the signer (hex private key, 0600).
python - <<'PY'
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
sk = Ed25519PrivateKey.generate()
open("evidence.key", "w").write(sk.private_bytes_raw().hex())
print(sk.public_key().public_bytes(Encoding.Raw, PublicFormat.Raw).hex())  # -> trust store
PY
chmod 600 evidence.key
"env": {
  "PRESIDIO_X402_MCP_EVIDENCE_KEY_FILE": "/etc/presidio/evidence.key",
  "PRESIDIO_X402_MCP_DECISION_PATH": "/var/log/presidio/x402-mcp-decisions.jsonl",
  "PRESIDIO_X402_MCP_REQUIRE_EVIDENCE_KEY": "1"
}

Verify offline with the parent's CLI against a trust store that pins the public key under the signer name:

echo '{"presidio-hardened-x402-mcp": {"alg": "ed25519", "public_key": "<public hex>"}}' > trust.json
python -m presidio_x402.decision_ref /var/log/presidio/x402-mcp-decisions.jsonl trust.json

Without a key the server behaves exactly as 0.2.x — audit log only — and logs one WARNING at startup saying signed evidence is disabled. A key without PRESIDIO_X402_MCP_DECISION_PATH, an unreadable key file, or a key the signer rejects is logged at ERROR and also leaves evidence off. Set PRESIDIO_X402_MCP_REQUIRE_EVIDENCE_KEY=1 to refuse to start in any of those cases instead. Once running, a failed write is logged and the gate's answer stands: a record of a decision never reverses the decision.

What a record says. payment-decision@1 always carries all five controls (pii → trusted_wallet → policy → replay → mpa). Each record holds real verdicts only for what its tool ran and NOT_EVALUATED for the rest: every tool screens the URL (pii), check_payment_policy adds policy, check_payment_replay adds replay; trusted_wallet and mpa are never evaluated here. NOT_EVALUATED never fails a decision and never claims a pass, so the controls block alone says which gate decided. Chain the three with prior_decision_refs to get one linked set per payment.

What it never contains. Raw resource_url, description, or reason; only the URL's scheme and host, the entity-type labels found, and hashes (policy snapshot, replay fingerprint, payment details). The gates see PII in the URL they are handed but pay it unchanged, so their PII verdict is PII_WARNED; screen_payment_metadata returns redacted strings and records PII_REDACTED. Fields an MCP tool never sees — payer wallet, network, the raw 402 offer — are recorded as unspecified / not-presented. Without a gate certificate the records carry no parents.

Gate-certificate parents (unreleased). To link payments back to the gate decision that authorised them, install presidio-hardened-x402-mcp[gate] and set PRESIDIO_X402_MCP_GATE_CERTIFICATE and PRESIDIO_X402_MCP_GATE_TRUST. At startup each certificate is verified with ikigov-assess's own verify_certificate (issuer signature, embedded evidence, validity, recomputed decision) and must record decision OPEN; its ADR-0006 identity then goes into every record's top-level parents, so a DAG walk runs classification → gate → payment. Anything wrong (one variable without the other, a file that does not verify, a gate that is not open, the extra missing, signed evidence not enabled) stops the server. The lineage comes from operator configuration only; no tool takes a parents argument, so an agent cannot add one. When the earliest certificate's not_after passes while the server runs, records stop naming any gate (all gate parents are dropped) and one WARNING is logged; the gates keep answering. Issue a new certificate and restart.

Modes

In-process (default). Wraps the local presidio-hardened-x402 library in the same process as the MCP server. No network, no API key, no quota. PII never leaves the agent host. Use this unless you have a specific reason not to.

HTTP-proxy. When both PRESIDIO_X402_MCP_REMOTE_BASE_URL and PRESIDIO_X402_MCP_REMOTE_API_KEY are set, screen_payment_metadata calls /v1/screen on the configured host (e.g. https://screen.presidio-group.eu) for centralized audit. On auth / quota / network failure, returns a structured { "error": "auth_error" | "rate_limit" | "unavailable", "detail": ..., "mode": "remote" } — never silently falls back to in-process. Tools 2 and 3 always stay in-process.

Composability

Designed to slot into agent flows alongside payment-execution and endpoint-safety MCP servers:

agent intent: pay https://api.foo.com/x with 1.50 USDC
    │
    ├─ x402station    preflight(url)            ← is the ENDPOINT safe? (decoys, dead, traps)
    │
    ├─ presidio-x402  screen_payment_metadata   ← is the PAYLOAD safe? (PII)
    ├─ presidio-x402  check_payment_policy      ← within budget?
    ├─ presidio-x402  check_payment_replay      ← not a duplicate?
    │
    └─ pay()

screen_payment_metadata is read-only and safe to interleave anywhere. The policy and replay gates record state on call — sequence them immediately before payment.

What none of these gates can see: a request body the agent made up. The three tools screen the 402 challenge's metadata and the spend; they never see the body the agent sends to a POST route. Independent measurement of the x402 and MPP catalogues (probe402, MCRI #001, 1 September 2026) found 1,521 of 8,056 listed POST routes — 18.9% — publish no usable request example, and 72% of those still return a payable quote at the wall. A route like that is listed, priced, and not machine-executable from the published contract. An agent that fills the gap by synthesising a body is guessing, and a guessed body is where user data enters the request unscreened. Posture: if the catalogue entry carries no request example or schema, stop at the 402 quote and surface it; do not invent a body to get past the wall. Put that rule in the agent's instructions — it is a decision the agent makes before any of these tools run.

Combined snippet: preflight → screen → pay

Endpoint-safety and payload-safety are independent signals — calling both is what you actually want before signing. Configure the two MCP servers side-by-side:

{
  "mcpServers": {
    "x402station":   { "command": "npx", "args": ["-y", "x402station-mcp"],
                       "env": { "AGENT_PRIVATE_KEY": "0x…" } },
    "presidio-x402": { "command": "uvx", "args": ["presidio-hardened-x402-mcp"] }
  }
}

Agent flow before signing a payment (pseudocode — each step is one MCP tool call):

# 1. endpoint safety: is the URL trustworthy? (x402station-mcp)
pf = preflight(url)
if not pf["ok"]:
    abort(reason=pf["warnings"])  # decoy / zombie / dead / price-trap

# 2. payload safety: redact PII before it leaves the host (presidio-x402)
s = screen_payment_metadata(resource_url=url, description=description, reason="")
url, description = s["redacted_resource_url"], s["redacted_description"]

# 3. spend gates: record-on-success, call exactly once each (presidio-x402)
if not check_payment_policy(url, amount_usd)["allowed"]:
    abort(reason="policy")
if check_payment_replay(url, pay_to, amount, currency, deadline_seconds)["is_replay"]:
    abort(reason="replay")

# 4. sign + pay
pay(url, amount, description=description)

The two servers are developed independently, on purpose — keeping the signals uncorrelated is the point. See x402station-mcp for the preflight tool's full output schema and warning catalog.

Notes for developers

  • Logs go to stderr (MCP clients capture stderr). stdout is reserved for JSON-RPC frames.

  • The package is a thin adapter. All security logic lives in presidio-hardened-x402 — read its docs for the entity-type catalog, policy semantics, evidence-ref verification, SLO broker, and audit-chain details.

  • This MCP release exposes the same three tools as 0.1.1. 0.3.0 adds signed payment-decision@1 emission from those tools and an optional prior_decision_refs argument on the two gates; the rest of the parent SLO/evidence/capability surface is not promoted into MCP.

  • When testing via mcp-inspector --cli, bare numeric --tool-arg amount=1.50 is auto-coerced to a float and rejected by the schema. Real MCP clients send proper JSON types; the tool's amount argument is a string to preserve precision.

  • Local dev: uv venv && uv pip install -e ".[dev]" && pytest tests/.

License

MIT. See LICENSE.


SDLC

This repository is on the open-source baseline of the PRESIDIO hardened-family SDLC (report · PDF). The controls measured for it, and any open gaps, are its row in the applicability matrix.

Roadmap (next 12 months)

  • Now / in flight — OpenSSF Best Practices silver and a Scorecard above 7: governance docs, a real CodeQL job alongside Bandit, least-privilege workflow tokens, and Atheris fuzzing of the configuration validators. Closing the remaining findings in SECURITY-AUDIT.md.

  • Next — hash-pinned CI dependencies, ideally as a family-wide change rather than in this repo alone.

  • Later (under evaluation) — signed releases with build provenance; tracking the MCP specification as it stabilises; exposing the parent library's capability-grant@1 enforcement as a fourth tool, if agent demand justifies the added surface.

Governance, Architecture, Security

  • Governance — roles, decision process, and how to become a maintainer.

  • Architecture — components, trust boundaries, and the core processing path.

  • Assurance case — the security claims and the evidence backing each one.

  • Security policy — supported versions and how to report a vulnerability.

  • Contributing — review bar, test policy, and verification commands.

  • Stability guarantees — what counts as the public API and what may not change.

Available Tools

3 tools
check_payment_policyA

Check whether a payment is allowed by the configured spending policy.

WARNING: this records the spend against rolling time-window ledgers. Call exactly once, immediately before submitting the payment. If you call this and then do not pay, the spend window will be inflated until it rolls over.

Configure limits at server startup via PRESIDIO_X402_MCP_* env vars.

Args: resource_url: x402 resource URL being paid. Screened first; only the redacted URL reaches the policy engine (per-endpoint limits match on it, so keep PII out of configured endpoint prefixes). amount_usd: Payment amount in USD-equivalent. prior_decision_refs: Optional decision_ref values this server returned earlier for the same payment (e.g. from screen_payment_metadata); linked into the signed record. Max 8.

Returns: {"allowed": true} on success, or {"allowed": false, "reason": str, "limit_usd": float, "amount_usd": float}; plus decision_ref when signed decision evidence is enabled.

Inputs: amount_usd (required), resource_url (required), prior_decision_refs. Returns: object

check_payment_replayA

Check whether this exact payment has been seen recently (replay protection).

WARNING: this records the fingerprint. Call exactly once, immediately before submitting the payment.

Cross-process detection requires PRESIDIO_X402_FINGERPRINT_KEY (and optionally PRESIDIO_X402_MCP_REDIS_URL); otherwise each MCP server process has its own ephemeral in-memory store.

Args: resource_url: x402 resource URL. pay_to: Recipient address. amount: Amount as string (preserves precision). currency: Currency symbol (e.g. "USDC"). deadline_seconds: Payment deadline as epoch seconds. prior_decision_refs: Optional decision_ref values this server returned earlier for the same payment; linked into the signed record. Max 8.

Returns: {"is_replay": false, "fingerprint": ""} on first seen, or {"is_replay": true, "fingerprint": ""} on duplicate; plus decision_ref when signed decision evidence is enabled.

Inputs: amount (required), pay_to (required), currency (required), resource_url (required), +2 more. Returns: object

screen_payment_metadataA

Screen x402 payment metadata for PII before signing the payment.

Call BEFORE sending the payment request. Detects emails, phone numbers, SSNs, names, and other PII in the resource URL, description, and reason fields and returns redacted strings plus per-field entity counts.

No side effects.

Runs in one of two modes:

  • in_process (default): wraps the local presidio_x402 PIIFilter.

  • remote: when both PRESIDIO_X402_MCP_REMOTE_BASE_URL and ..._REMOTE_API_KEY are set, POSTs to /v1/screen on that host for centralized audit. On remote failure, returns a structured error dict instead of silently falling back — the caller must decide whether to retry, accept reduced screening, or abort.

Args: resource_url: x402 resource URL the agent is about to pay (max 2048 chars). description: Human-readable description (max 4096 chars). reason: Reason / memo string (max 4096 chars). entities: Optional whitelist of Presidio entity types to detect. If None, all configured entities are scanned.

Returns: On success: dict with keys redacted_resource_url, redacted_description, redacted_reason, entities_found (list of {entity_type, field, count}), and mode (one of "in_process", "remote"); plus decision_ref when signed decision evidence is enabled (pass it to the gates as prior_decision_refs). On remote failure: dict with keys error (one of "auth_error", "rate_limit", "unavailable"), detail, optional retry_after (for rate_limit), and mode ("remote").

Inputs: resource_url (required), reason, entities, description. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.5/5.0

    Scored across 3 tools

    Disambiguation5/5

    Each tool targets a distinct pre-payment concern: PII screening, spending-policy authorization, and replay detection. Their inputs overlap, but the roles are complementary and clearly separated by purpose and description.

    Naming Consistency5/5

    All names use snake_case and follow a predictable verb_payment_<object> pattern. The slight verb variation (screen vs. check) reflects genuinely different actions while remaining consistent.

    Tool Count5/5

    Three tools fit a focused pre-payment hardening pipeline, with each tool earning its place. There is no filler or redundant surface for this narrow scope.

    Completeness4/5

    The set covers the core safety checks: PII screening, policy limits, and replay protection. Minor gaps exist around inspecting configured policy limits or releasing recorded spend/fingerprints when a payment is not completed, though the warnings document these operational constraints.

    Maintenance

    ActivityActive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      Before an AI agent pays an x402 endpoint, checks whether it's safe to pay: liveness, scam/anomaly scan (payTo hijack, bait-and-switch, honeypot), and on-chain receiver verification. ~70% of x402 endpoints are dead or scams.
      3
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      MCP server for assessing counterparty risk in x402 payments using on-chain data, providing risk scores, decisions, and wallet spending policies to prevent fraud and unauthorized payments.
      10
      1
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Pre-spend trust layer for agents paying over x402 on Solana, providing seller vetting and readiness checks before USDC leaves the wallet.
      MIT