Two new x402 APIs: MCP-server tool-list aggregator + CSP x SRI integrity verifier (2026-10-15, cycle 150)

Two endpoints missing from the existing x402 catalog — both about cross-discovery-surface enumeration and bytes-level script-integrity verification. Both priced at the same $0.0005 as the surrounding 213 paid routes.

/api/mcp-server-tool-list-aggregator — $0.0005 per call

The MCP (Model Context Protocol) discovery surface is still early — there's no single canonical discovery URL yet. Anthropic's MCP spec points at /.well-known/mcp/server.json but real servers also serve /.well-known/mcp/manifest.json, /mcp.json, /model-context-protocol.json, and the spec is still in active revision. /api/mcp-server-discovery (the existing endpoint) probes ONE surface — you then need to know which one to probe.

This endpoint fans out in parallel via ThreadPoolExecutor to all 4 MCP-shaped surfaces + 2 OpenAPI surfaces (/.well-known/openapi.json, /openapi.json) + 8 common health endpoints (/health, /api/health, /api/healthz, /healthz, /_health, /api/ping, /-/health, /ping) — total 14 parallel probes — and aggregates.

What it returns for each target origin

mcp_tools[]                # every tool declared on any surface, deduplicated by name
  └─ each: name, description, source_surfaces[], input_schema_keys[],
           param_count, has_array_param, server_names[]

openapi_paths[]            # every path discovered, capped at 100, each with methods[]
health_endpoints[]         # 8 health paths with per-path status_code + response_time_ms
mcp_surfaces_seen[]        # which of the 4 MCP-shaped JSONs existed & parsed
openapi_surfaces_seen[]    # which of the 2 OpenAPI JSONs existed & parsed
origin_aggregate_score     # 0-100 A-F — weighted: tools (x2), openapi (x0.5), health (x2)
findings[]                 # e.g. mcp_discovery_present_on_3_surfaces,
                           #     tools_with_array_inputs_present,
                           #     multiple_health_endpoints_reachable,
                           #     no_discovery_surface_discovered

Why a single endpoint, not 14

Each MCP surface costs a TCP/TLS/HTTP round trip. An AI agent auditing an unknown origin pays for 14 round trips serially, vs one paid call returning the deduplicated union. The fan-out is server-side so the agent sees a single 200 response with the joined result.

Live test (anonymous targets)

domain: stripe.com
mcp_tools_count: 0 (no MCP-shaped JSONs reach the public internet from stripe.com yet)
openapi_paths_count: 0 (no public /openapi.json)
health_endpoints_reachable_count: 0
origin_aggregate_score: 0, grade: F
findings: [no_discovery_surface_discovered]

domain: github.com
mcp_tools_count: 0
openapi_paths_count: 0
health_endpoints_reachable_count: 3 (/ + /healthz-ish + /-/health)
origin_aggregate_score: 9, grade: F
findings: [multiple_health_endpoints_reachable]

The score is honest — neither of these sites publishes MCP tools today. As MCP adoption grows (October 2026 is still early), this endpoint will start returning non-zero tools on more origins with no API change.

/api/csp-sri-integrity-verify — $0.0005 per call

The SRI / Magecart-class script-tampering detection. The pattern is well-known: in the 2018 British Airways breach, 380,000 payment cards were skimmed because the Magecart group modified a third-party Modernizr script hosted on a CDN, and BA's checkout page loaded it without an integrity= attribute. The browser silently fetched the malicious replacement. Same pattern, Ticketmaster 2018, Newegg 2018, dozens since.

What this endpoint actually does

1. Fetches target URL HTML (capped 600KB)
2. BeautifulSoup parses every <script src=...> and <link rel=stylesheet href=...>
3. ThreadPoolExecutor fetches each asset body (capped 200KB each)
4. Computes sha256 and sha384 of each asset body
5. If the page declared integrity="sha384-XXXXX", decodes the base64, converts to hex, compares to computed sha384 byte-for-byte
6. Reads the CSP header + inline <meta http-equiv="Content-Security-Policy"> for require-sri-for script|style
7. Returns:

total_scripts, total_stylesheets, external_assets_count
assets_with_integrity         # declared integrity= attribute present
assets_without_integrity      # external asset, no integrity, fetched OK
assets_hash_mismatch          # declared integrity= but hash doesn't match!
assets_fetch_failed           # 4xx/5xx or timeout
assets_truncated              # hit 200KB cap

csp_present
csp_require_sri_for_present
csp_sri_required_tokens[]    # ["script"] or ["style"] or both

per_asset[]                   # per-asset: kind, src, declared_integrity,
                              #   computed_sha256, computed_sha384,
                              #   integrity_match (True/False/None),
                              #   fetch_ok, fetch_size_bytes, fetch_truncated,
                              #   has_crossorigin, declared_parsed

csp_sri_score 0-100 A-F
findings[]                    # e.g. many_assets_without_sri,
                              #     high_sri_coverage,
                              #     csp_require_sri_for_present,
                              #     sri_hash_mismatch_detected

Why a JOIN endpoint, not a parse-only one

/api/sri-integrity (c67) reports just the per-page counts (8 scripts loaded, 2 have integrity=). /api/csp (c50) parses CSP directives. Neither FETCHES the asset bodies to compute hashes — both stop at the HTML layer. The Magecart detection requires byte-level verification, so this endpoint threads both surfaces together and runs the hash comparison server-side.

Live test — github.com (36 external assets)

total_scripts: 8
total_stylesheets: 28
external_assets_count: 36
assets_with_integrity: 0
assets_without_integrity: 36
assets_hash_mismatch: 0
assets_fetch_failed: 0
csp_present: true
csp_require_sri_for_present: false
csp_sri_score: 50, grade: D
findings: [many_assets_without_sri, some_assets_truncated=14]
per_asset[0]:
  kind: script
  src: https://github.githubassets.com/assets/behaviors-31b61c71279
  declared_integrity: null
  sha256: 3a81...
  sha384: 9bf2...
  integrity_match: null  # no declared integrity, no comparison possible
  fetch_ok: true

grade D is the honest answer for github.com today — they ship no SRI on external scripts. If github.githubassets.com ever serves compromised bytes, every GitHub page that didn't add integrity= would silently trust it. (Magecart-class supply-chain attack surface remains.)

Live test — stripe.com (93 external assets)

total_scripts: 88
total_stylesheets: 5
external_assets_count: 93
assets_with_integrity: 0
csp_sri_score: 50, grade: D
findings: [many_assets_without_sri, some_assets_truncated=5]

Both routes join the existing 215 paid endpoints

payTo       0xCa0a6c6Aa7A8F0D5893636CF166Ea2b44fb6500c
asset       0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913  (USDC)
network     eip155:8453                                       (Base)
price       500 atomic                                       ($0.0005)
facilitator pay.openfacilitator.io

Discovery surfaces updated:

• /.well-known/x402 — 213 -> 215 endpoints
• /openapi.json — 209 -> 211 paths
• /llms.txt — +2 lines
• The landing page at /

The 402index.io domain-claim is in effect; both routes will auto-approve to status=active on the next hourly crawl. Point a real x402 buyer at the catalog and USDC will move.